Tous les produits
Search

Ce produit

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

    Centre de documentation

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

    Dernière mise à jour :Aug 11, 2026

    Déployez un cluster géré ACK doté de plusieurs pools de nœuds et des modules complémentaires essentiels à l'aide de Terraform.

    Remarque

    Exécutez directement l'exemple de code de ce tutoriel depuis le portail OpenAPI Portal.

    Prérequis

    • Le service ACK est activé (consultez la rubrique Activer ACK avec Terraform).

    • Cette stratégie d'autorisation permet à l'utilisateur RAM de créer, consulter et supprimer des VPC, des vSwitch et des clusters 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": "*"
    }
  ]
}

    • Préparez un environnement d'exécution Terraform. Vous pouvez utiliser Terraform de l'une des manières suivantes :

      Important

      Assurez-vous que votre version de Terraform est égale ou supérieure à 0.12.28. Pour vérifier la version, exécutez la commande terraform --version.

    Ressources

    Remarque

    Certaines ressources utilisées dans cet exemple entraînent des frais. Pour éviter toute facturation indésirable, supprimez ces ressources lorsque vous n'en avez plus besoin.

    Générer la configuration Terraform depuis la console

    Pour personnaliser les configurations au-delà des exemples fournis, exportez la configuration Terraform depuis la console ACK.

    1. Connectez-vous à la console ACK. Dans le volet de navigation de gauche, cliquez sur Clusters.

    2. Sur la page Clusters, cliquez sur Cluster Templates.

    3. Dans la boîte de dialogue, sélectionnez un type de cluster, cliquez sur Create, puis configurez les détails du cluster sur la page Cluster Configurations.

    4. Une fois la configuration terminée, accédez à l'étape Confirm et cliquez sur Console-to-Code en haut à droite.

    5. Dans la barre latérale, cliquez sur l'onglet Terraform pour afficher et copier le code HCL généré automatiquement.

    Créer un cluster géré ACK avec Terway

    Cet exemple crée un cluster géré ACK comprenant un pool de nœuds standard, un pool de nœuds managé et un pool de nœuds à mise à l'échelle automatique. Le cluster inclut plusieurs modules complémentaires par défaut : Terway (réseau), csi-plugin et csi-provisioner (stockage), loongcollector (journalisation), Nginx Ingress Controller, ack-arms-prometheus (surveillance) et ack-node-problem-detector (diagnostic des nœuds).

    1. Créez un répertoire de travail, créez un fichier de configuration nommé main.tf dans ce répertoire, puis copiez le code suivant dans 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. Exécutez la commande suivante pour initialiser l'environnement d'exécution Terraform.

      terraform init

      Résultat attendu :

      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. Créez un plan d'exécution et prévisualisez les modifications.

      terraform plan

    4. Exécutez la commande suivante pour créer le cluster.

      terraform apply

      Saisissez yes lorsque vous y êtes invité, puis appuyez sur Entrée. La sortie suivante indique que le cluster ACK est créé :

      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. Vérifiez les résultats

      Terraform show

      Exécutez la commande suivante pour afficher les détails des ressources créées par Terraform.

      terraform show

      Console ACK

      Connectez-vous à la console ACK pour afficher le cluster créé.

    Nettoyage des ressources

    Pour libérer les ressources et arrêter la facturation, exécutez la commande terraform destroy. Pour plus d'informations sur la commande terraform destroy, consultez la rubrique Commandes courantes.

    terraform destroy