Terraform-Anbieter verstehen

In Terraform ist ein Anbieter ein Plugin, das mit Cloud-Anbietern, Tools von Drittanbietern und anderen APIs interagiert. Um Terraform mit zu verwenden, verwenden Sie den AWS Anbieter AWS, der mit Ressourcen interagiert. AWS

Wenn Sie die AWS CloudFormation Registrierung noch nie verwendet haben, um Erweiterungen von Drittanbietern in Ihre Deployment-Stacks zu integrieren, ist es möglicherweise gewöhnungsbedürftig, sich an Terraform-Anbieter zu gewöhnen. Da CloudFormation es sich um systemeigene Ressourcen handelt AWS, ist der Anbieter von AWS Ressourcen standardmäßig bereits vorhanden. Terraform hat dagegen keinen einzigen Standardanbieter, sodass nichts über die Herkunft einer bestimmten Ressource angenommen werden kann. Das bedeutet, dass das Erste, was in einer Terraform-Konfigurationsdatei deklariert werden muss, genau ist, wohin die Ressourcen gehen und wie sie dorthin gelangen werden.

Diese Unterscheidung verleiht Terraform eine zusätzliche Komplexitätsebene, die es nicht gibt. CloudFormation Diese Komplexität bietet jedoch eine erhöhte Flexibilität. Sie können mehrere Anbieter innerhalb eines einzigen Terraform-Moduls deklarieren, und dann können die erstellten zugrunde liegenden Ressourcen als Teil derselben Bereitstellungsebene miteinander interagieren.

Dies kann auf vielfältige Weise nützlich sein. Anbieter müssen nicht unbedingt für separate Cloud-Anbieter zuständig sein. Anbieter können jede Quelle für Cloud-Ressourcen repräsentieren. Nehmen wir zum Beispiel Amazon Elastic Kubernetes Service (Amazon EKS). Wenn Sie einen Amazon EKS-Cluster bereitstellen, möchten Sie möglicherweise Helm-Diagramme verwenden, um Erweiterungen von Drittanbietern zu verwalten, und Kubernetes selbst zur Verwaltung von Pod-Ressourcen verwenden. Da AWSHelm und Kubernetes alle ihre eigenen Terraform-Anbieter haben, können Sie diese Ressourcen alle gleichzeitig bereitstellen und integrieren und dann Werte zwischen ihnen weitergeben.

Im folgenden Codebeispiel für Terraform erstellt der AWS Anbieter einen Amazon EKS-Cluster, und dann werden die resultierenden Kubernetes-Konfigurationsinformationen sowohl an den Helm- als auch an den Kubernetes-Anbieter weitergegeben.

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = ">= 4.33.0"
    }

    helm = {
      source  = "hashicorp/helm"
      version = "2.12.1"
    }

    kubernetes = {
      source  = "hashicorp/kubernetes"
      version = "2.26.0"
    }
  }
  required_version = ">= 1.2.0"
}

provider "aws" {
  region = "us-west-2"
}

resource "aws_eks_cluster" "example_0" {
  name     = "example_0"
  role_arn = aws_iam_role.cluster_role.arn
  vpc_config {
    endpoint_private_access = true
    endpoint_public_access  = true
    subnet_ids              = var.subnet_ids
  }
}

locals {
  host        = aws_eks_cluster.example_0.endpoint
  certificate = base64decode(aws_eks_cluster.example_0.certificate_authority.data)
}

provider "helm" {
  kubernetes {
    host                   = local.host
    cluster_ca_certificate = local.certificate
    # exec allows for an authentication command to be run to obtain user
    # credentials rather than having them stored directly in the file
    exec {
      api_version = "client.authentication.k8s.io/v1beta1"
      args        = ["eks", "get-token", "--cluster-name", aws_eks_cluster.example_0.name]
      command     = "aws"
    }
  }
}

provider "kubernetes" {
  host                   = local.host
  cluster_ca_certificate = local.certificate
  exec {
    api_version = "client.authentication.k8s.io/v1beta1"
    args        = ["eks", "get-token", "--cluster-name", aws_eks_cluster.example_0.name]
    command     = "aws"
  }
}

Wenn es um die beiden IaC-Tools geht, gibt es einen Kompromiss in Bezug auf Anbieter. Terraform stützt sich ausschließlich auf externe Anbieterpakete, die den Motor für die Bereitstellung bilden. CloudFormation unterstützt intern alle wichtigen Prozesse. AWS Mit CloudFormation müssen Sie sich nur dann Gedanken über Drittanbieter machen, wenn Sie eine Erweiterung eines Drittanbieters integrieren möchten. Jeder Ansatz hat Vor- und Nachteile. Welches für Sie das Richtige ist, würde den Rahmen dieses Leitfadens sprengen, aber es ist wichtig, bei der Bewertung beider Tools den Unterschied zu berücksichtigen.

Terraform-Aliase verwenden

In Terraform können Sie benutzerdefinierte Konfigurationen an jeden Anbieter übergeben. Was ist also, wenn Sie mehrere Anbieterkonfigurationen innerhalb desselben Moduls verwenden möchten? In diesem Fall müssten Sie einen Alias verwenden.  Aliase helfen Ihnen bei der Auswahl des Anbieters, der auf Ressourcen- oder Modulebene verwendet werden soll. Wenn Sie mehr als eine Instanz desselben Anbieters haben, verwenden Sie einen Alias, um die nicht standardmäßigen Instanzen zu definieren. Beispielsweise kann es sich bei Ihrer Standardanbieterinstanz um eine bestimmte Instanz handeln AWS-Region, aber Sie verwenden Aliase, um alternative Regionen zu definieren.

Das folgende Terraform-Beispiel zeigt, wie Sie einen Alias verwenden, um Buckets in verschiedenen Bereichen bereitzustellen. AWS-Regionen Die Standardregion für den Anbieter istus-west-2, aber Sie können den Ost-Alias verwenden, um Ressourcen bereitzustellen. us-east-2

provider "aws" {
  region = "us-west-2"
}

provider "aws" {
  alias  = "east"
  region = "us-east-2"
}

resource "aws_s3_bucket" "myWestS3Bucket" {
  bucket = "my-west-s3-bucket"
}

resource "aws_s3_bucket" "myEastS3Bucket" {
  provider = aws.east
  bucket   = "my-east-s3-bucket"
}

Wenn Sie alias zusammen mit dem provider Metaargument ein verwenden, können Sie, wie im vorherigen Beispiel gezeigt, eine andere Anbieterkonfiguration für bestimmte Ressourcen angeben. Die Bereitstellung mehrerer Ressourcen AWS-Regionen in einem einzigen Stapel ist erst der Anfang. Das Aliasing von Anbietern ist in vielerlei Hinsicht unglaublich praktisch.

Beispielsweise ist es sehr üblich, mehrere Kubernetes-Cluster gleichzeitig bereitzustellen. Aliase können Ihnen helfen, zusätzliche Helm- und Kubernetes-Anbieter zu konfigurieren, sodass Sie diese Drittanbieter-Tools für verschiedene Amazon EKS-Ressourcen unterschiedlich verwenden können. Das folgende Terraform-Codebeispiel veranschaulicht, wie Aliase zur Ausführung dieser Aufgabe verwendet werden.

resource "aws_eks_cluster" "example_0" {
  name     = "example_0"
  role_arn = aws_iam_role.cluster_role.arn
  vpc_config {
    endpoint_private_access = true
    endpoint_public_access  = true
    subnet_ids              = var.subnet_ids[0]
  }
}

resource "aws_eks_cluster" "example_1" {
  name     = "example_1"
  role_arn = aws_iam_role.cluster_role.arn
  vpc_config {
    endpoint_private_access = true
    endpoint_public_access  = true
    subnet_ids              = var.subnet_ids[1]
  }
}

locals {
  host         = aws_eks_cluster.example_0.endpoint
  certificate  = base64decode(aws_eks_cluster.example_0.certificate_authority.data)
  host1        = aws_eks_cluster.example_1.endpoint
  certificate1 = base64decode(aws_eks_cluster.example_1.certificate_authority.data)
}

provider "helm" {
  kubernetes {
    host                   = local.host
    cluster_ca_certificate = local.certificate
    exec {
      api_version = "client.authentication.k8s.io/v1beta1"
      args        = ["eks", "get-token", "--cluster-name", aws_eks_cluster.example_0.name]
      command     = "aws"
    }
  }
}

provider "helm" {
  alias = "helm1"
  kubernetes {
    host                   = local.host1
    cluster_ca_certificate = local.certificate1
    exec {
      api_version = "client.authentication.k8s.io/v1beta1"
      args        = ["eks", "get-token", "--cluster-name", aws_eks_cluster.example_1.name]
      command     = "aws"
    }
  }
}

provider "kubernetes" {
  host                   = local.host
  cluster_ca_certificate = local.certificate
  exec {
    api_version = "client.authentication.k8s.io/v1beta1"
    args        = ["eks", "get-token", "--cluster-name", aws_eks_cluster.example_0.name]
    command     = "aws"
  }
}

provider "kubernetes" {
  alias                  = "kubernetes1"
  host                   = local.host1
  cluster_ca_certificate = local.certificate1
  exec {
    api_version = "client.authentication.k8s.io/v1beta1"
    args        = ["eks", "get-token", "--cluster-name", aws_eks_cluster.example_1.name]
    command     = "aws"
  }
}