Todos os produtos
Search

Este produto

    Container Service for Kubernetes:Create an ACK managed cluster with Terraform

    Central de documentação

    Container Service for Kubernetes:Create an ACK managed cluster with Terraform

    Última atualização: Sep 18, 2026

    Use o Terraform para provisionar um cluster gerenciado do ACK com vários pools de nós e add-ons essenciais.

    Nota

    Execute o código de exemplo deste tutorial diretamente no portal OpenAPI.

    Pré-requisitos

    • O ACK está ativado (activate ACK by using Terraform).

    • Par de AccessKey do seu usuário do RAM

      Use um usuário do RAM em vez da conta raiz. Permissões limitadas reduzem a exposição em caso de comprometimento das credenciais.

    • Esta política de permissões permite ao usuário do RAM criar, visualizar e excluir VPCs, vSwitches e clusters do ACK.

      {
  "Version": "1",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "vpc:CreateVpc",
        "vpc:CreateVSwitch",
        "cs:CreateCluster",
        "vpc:DescribeVpcAttribute",
        "vpc:DescribeVSwitchAttributes",
        "vpc:DescribeRouteTableList",
        "vpc:DescribeNatGateways",
        "cs:DescribeTaskInfo",
        "cs:DescribeClusterDetail",
        "cs:GetClusterCerts",
        "cs:CheckControlPlaneLogEnable",
        "cs:CreateClusterNodePool",
        "cs:DescribeClusterNodePoolDetail",
        "cs:ModifyClusterNodePool",
        "vpc:DeleteVpc",
        "vpc:DeleteVSwitch",
        "cs:DeleteCluster",
        "cs:DeleteClusterNodepool"
      ],
      "Resource": "*"
    }
  ]
}

    • Prepare um ambiente de execução do Terraform. Use o Terraform de uma das seguintes maneiras:

      Importante

      Certifique-se de que a versão do seu Terraform seja 0.12.28 ou posterior. Para verificar a versão, execute o comando terraform --version.

    Recursos

    Nota

    Alguns recursos usados neste exemplo geram custos. Para evitar cobranças indesejadas, exclua esses recursos quando não forem mais necessários.

    Gere a configuração do Terraform a partir do console

    Para personalizar as configurações além dos exemplos fornecidos, exporte a configuração do Terraform pelo console do ACK.

    1. Acesse o console do ACK. No painel de navegação à esquerda, clique em Clusters.

    2. Na página Clusters, clique em Cluster Templates.

    3. Na caixa de diálogo, selecione um tipo de cluster, clique em Create e, em seguida, configure os detalhes do cluster na página Cluster Configurations.

    4. Após concluir a configuração, vá para a etapa Confirm e clique em Console-to-Code no canto superior direito.

    5. Na barra lateral, clique na guia Terraform para visualizar e copiar o código HCL gerado automaticamente.

    Crie um cluster gerenciado do ACK com o Terway

    Este exemplo cria um cluster gerenciado do ACK com um pool de nós comum, um pool de nós gerenciado e um pool de nós com dimensionamento automático. O cluster inclui vários add-ons padrão: Terway (rede), csi-plugin e csi-provisioner (armazenamento), loongcollector (log), Nginx Ingress Controller, ack-arms-prometheus (monitoramento) e ack-node-problem-detector (diagnóstico de nós).

    1. Crie um diretório de trabalho e um arquivo de configuração chamado main.tf nesse diretório. Em seguida, copie o seguinte código para o main.tf.

      provider "alicloud" {
  region = var.region_id
}

variable "region_id" {
  type    = string
  default = "cn-shenzhen"
}

variable "cluster_spec" {
  type        = string
  description = "The specifications for the Kubernetes cluster. This can be empty. Valid values: ack.standard: Standard managed clusters; ack.pro.small: Professional managed clusters."
  default     = "ack.pro.small"
}

# The availability zones for the vSwitches.
variable "availability_zone" {
  description = "The availability zones for the vSwitches."
  default     = ["cn-shenzhen-c", "cn-shenzhen-e", "cn-shenzhen-f"]
}

# A list of existing vSwitch IDs.
variable "node_vswitch_ids" {
  description = "A list of existing vSwitch IDs for Terway nodes."
  type        = list(string)
  default     = []
}

# A list of CIDR blocks for creating new vSwitches.
variable "node_vswitch_cidrs" {
  description = "A list of CIDR blocks for creating new vSwitches when 'node_vswitch_ids' is not specified."
  type        = list(string)
  default     = ["172.16.0.0/23", "172.16.2.0/23", "172.16.4.0/23"]
}

# The configuration of the Terway network add-on. If empty, new Terway vSwitches are created based on terway_vswitch_cidrs by default.
variable "terway_vswitch_ids" {
  description = "List of existing pod vswitch ids for terway."
  type        = list(string)
  default     = []
}

# The CIDR blocks for creating vSwitches for Terway when terway_vswitch_ids is not specified.
variable "terway_vswitch_cidrs" {
  description = "List of cidr blocks used to create several new vswitches when 'terway_vswitch_ids' is not specified."
  type        = list(string)
  default     = ["172.16.208.0/20", "172.16.224.0/20", "172.16.240.0/20"]
}

# The ECS instance types for worker nodes.
variable "worker_instance_types" {
  description = "The ECS instance types for worker nodes."
  default     = ["ecs.g6.2xlarge", "ecs.g6.xlarge"]
}

# The add-ons to install on the ACK cluster. Includes Terway (network), csi-plugin (storage), csi-provisioner (storage), loongcollector (logging), Nginx Ingress Controller, ack-arms-prometheus (monitoring), and ack-node-problem-detector (node diagnostics).
variable "cluster_addons" {
  type = list(object({
    name   = string
    config = string
  }))
  default = [
    {
      "name"   = "terway-eniip",
      "config" = "",
    },
    {
      "name"   = "loongcollector",
      "config" = "{\"IngressDashboardEnabled\":\"true\"}",
    },
    {
      "name"   = "nginx-ingress-controller",
      "config" = "{\"IngressSlbNetworkType\":\"internet\"}",
    },
    {
      "name"   = "arms-prometheus",
      "config" = "",
    },
    {
      "name"   = "ack-node-problem-detector",
      "config" = "{\"sls_project_name\":\"\"}",
    },
    {
      "name"   = "csi-plugin",
      "config" = "",
    },
    {
      "name"   = "csi-provisioner",
      "config" = "",
    }
  ]
}

# The name prefix for the ACK managed cluster.
variable "k8s_name_prefix" {
  description = "The name prefix for the managed Kubernetes cluster."
  default     = "tf-ack-shenzhen"
}

# Default resource names.
locals {
  k8s_name_terway         = substr(join("-", [var.k8s_name_prefix, "terway"]), 0, 63)
  k8s_name_flannel        = substr(join("-", [var.k8s_name_prefix, "flannel"]), 0, 63)
  k8s_name_ask            = substr(join("-", [var.k8s_name_prefix, "ask"]), 0, 63)
  new_vpc_name            = "tf-vpc-172-16"
  new_vsw_name_azD        = "tf-vswitch-azD-172-16-0"
  new_vsw_name_azE        = "tf-vswitch-azE-172-16-2"
  new_vsw_name_azF        = "tf-vswitch-azF-172-16-4"
  nodepool_name           = "default-nodepool"
  managed_nodepool_name   = "managed-node-pool"
  autoscale_nodepool_name = "autoscale-node-pool"
  log_project_name        = "log-for-${local.k8s_name_terway}"
}

# ECS instance configuration for nodes. Queries for ECS instance types that meet the CPU and memory requirements.
data "alicloud_instance_types" "default" {
  cpu_core_count       = 8
  memory_size          = 32
  availability_zone    = var.availability_zone[0]
  kubernetes_node_role = "Worker"
}

# VPC.
resource "alicloud_vpc" "default" {
  vpc_name   = local.new_vpc_name
  cidr_block = "172.16.0.0/12"
}

# Node vSwitches.
resource "alicloud_vswitch" "vswitches" {
  count      = length(var.node_vswitch_ids) > 0 ? 0 : length(var.node_vswitch_cidrs)
  vpc_id     = alicloud_vpc.default.id
  cidr_block = element(var.node_vswitch_cidrs, count.index)
  zone_id    = element(var.availability_zone, count.index)
}

# The vSwitches for pods.
resource "alicloud_vswitch" "terway_vswitches" {
  count      = length(var.terway_vswitch_ids) > 0 ? 0 : length(var.terway_vswitch_cidrs)
  vpc_id     = alicloud_vpc.default.id
  cidr_block = element(var.terway_vswitch_cidrs, count.index)
  zone_id    = element(var.availability_zone, count.index)
}

# ACK managed cluster.
resource "alicloud_cs_managed_kubernetes" "default" {
  name                         = local.k8s_name_terway                                         # The name of the Kubernetes cluster.
  cluster_spec                 = var.cluster_spec                                              # Creates a professional managed cluster.
  vswitch_ids                  = split(",", join(",", alicloud_vswitch.vswitches.*.id))        # The vSwitches for the node pool. Specify one or more vSwitch IDs. The vSwitches must be in the specified availability zones.
  pod_vswitch_ids              = split(",", join(",", alicloud_vswitch.terway_vswitches.*.id)) # Pod vSwitches.
  new_nat_gateway              = true                                                          # Specifies whether to create a new nat gateway when you create the Kubernetes cluster. Default value: true.
  service_cidr                 = "10.11.0.0/16"                                                # The Service CIDR block, required when using Flannel networking. It must not overlap with the VPC CIDR block or that of another Kubernetes cluster in the same VPC. This parameter cannot be changed after the cluster is created. The cluster supports a maximum of 256 nodes.
  slb_internet_enabled         = true                                                          # Specifies whether to create an Internet-facing load balancer for the API server. Default value: false.
  enable_rrsa                  = true
  control_plane_log_components = ["apiserver", "kcm", "scheduler", "ccm"] # Control plane logs.
  dynamic "addons" {                                                      # Add-on configuration.
    for_each = var.cluster_addons
    content {
      name   = lookup(addons.value, "name", var.cluster_addons)
      config = lookup(addons.value, "config", var.cluster_addons)
    }
  }
}

# Regular node pool.
resource "alicloud_cs_kubernetes_node_pool" "default" {
  cluster_id            = alicloud_cs_managed_kubernetes.default.id              # The ID of the Kubernetes cluster.
  node_pool_name        = local.nodepool_name                                    # The name of the node pool.
  vswitch_ids           = split(",", join(",", alicloud_vswitch.vswitches.*.id)) # The vSwitches for the node pool. Specify one or more vSwitch IDs. The vSwitches must be in the specified availability zones.
  instance_types        = var.worker_instance_types
  instance_charge_type  = "PostPaid"
  desired_size          = 2            # The desired number of nodes in the node pool.
  install_cloud_monitor = true         # Specifies whether to install CloudMonitor on the nodes.
  system_disk_category  = "cloud_efficiency"
  system_disk_size      = 100
  image_type            = "AliyunLinux"
  data_disks {              # Data disk configuration for the node.
    category = "cloud_essd" # The category of the data disk.
    size     = 120          # The size of the data disk.
  }
}

# Create a managed node pool.
resource "alicloud_cs_kubernetes_node_pool" "managed_node_pool" {
  cluster_id     = alicloud_cs_managed_kubernetes.default.id              # The ID of the Kubernetes cluster.
  node_pool_name = local.managed_nodepool_name                            # The name of the node pool.
  vswitch_ids    = split(",", join(",", alicloud_vswitch.vswitches.*.id)) # The vSwitches for the node pool. Specify one or more vSwitch IDs. The vSwitches must be in the specified availability zones.
  desired_size   = 0                                                      # The desired number of nodes in the node pool.
  management {
    auto_repair     = true
    auto_upgrade    = true
    max_unavailable = 1
  }
  instance_types        = var.worker_instance_types
  instance_charge_type  = "PostPaid"
  install_cloud_monitor = true
  system_disk_category  = "cloud_efficiency"
  system_disk_size      = 100
  image_type            = "AliyunLinux"
  data_disks {
    category = "cloud_essd"
    size     = 120
  }
}

# Create an auto-scaling node pool. The node pool can be scaled out to a maximum of 10 nodes and must have at least 1 node.
resource "alicloud_cs_kubernetes_node_pool" "autoscale_node_pool" {
  cluster_id     = alicloud_cs_managed_kubernetes.default.id
  node_pool_name = local.autoscale_nodepool_name
  vswitch_ids    = split(",", join(",", alicloud_vswitch.vswitches.*.id))
  scaling_config {
    min_size = 1
    max_size = 10
  }
  instance_types        = var.worker_instance_types
  install_cloud_monitor = true         # Specifies whether to install CloudMonitor on the nodes.
  system_disk_category  = "cloud_efficiency"
  system_disk_size      = 100
  image_type            = "AliyunLinux3"
  data_disks {              # Data disk configuration for the node.
    category = "cloud_essd" # The category of the data disk.
    size     = 120          # The size of the data disk.
  }
}

    2. Execute o comando a seguir para inicializar o ambiente de execução do Terraform.

      terraform init

      Saída esperada:

      Terraform has been successfully initialized!

You may now begin working with Terraform. Try running "terraform plan" to see
any changes that are required for your infrastructure. All Terraform commands
should now work.

If you ever set or change modules or backend configuration for Terraform,
rerun this command to reinitialize your working directory. If you forget, other
commands will detect it and remind you to do so if necessary.

    3. Crie um plano de execução e visualize as alterações.

      terraform plan

    4. Execute o comando a seguir para criar o cluster.

      terraform apply

      Digite yes quando solicitado e pressione Enter. A saída a seguir indica que o cluster do ACK foi criado:

      Do you want to perform these actions?
  Terraform will perform the actions described above.
  Only 'yes' will be accepted to approve.

  Enter a value: yes

...
alicloud_cs_managed_kubernetes.default: Creation complete after 5m48s [id=ccb53e72ec6c447c990762800********]
...

Apply complete! Resources: 11 added, 0 changed, 0 destroyed.

    5. Verifique os resultados

      Terraform show

      Execute o comando a seguir para visualizar os detalhes dos recursos criados pelo Terraform.

      terraform show

      ACK console

      Acesse o console do ACK para visualizar o cluster criado.

    Limpeza de recursos

    Para liberar recursos e evitar cobranças, execute o comando terraform destroy. Para obter mais informações sobre o comando terraform destroy, consulte Common commands.

    terraform destroy