Inicio rápido: Creación de un clúster automático de Azure Kubernetes Service (AKS)

• Use el entorno de Bash en Azure Cloud Shell. Para obtener más información, consulte Get started with Azure Cloud Shell.

  

• Si prefiere ejecutar comandos de referencia de la CLI localmente, instale la CLI de Azure. Si se ejecuta en Windows o macOS, considere la posibilidad de ejecutar CLI de Azure en un contenedor de Docker. Para obtener más información, consulte Cómo ejecutar el CLI de Azure en un contenedor de Docker.

  • Si usa una instalación local, inicie sesión en el CLI de Azure mediante el comando az login. Para finalizar el proceso de autenticación, siga los pasos que se muestran en el terminal. Para ver otras opciones de inicio de sesión, consulte Authenticate para Azure con CLI de Azure.

  • Cuando se le solicite, instale la extensión CLI de Azure en el primer uso. Para obtener más información sobre las extensiones, consulte Use y administre extensiones con el CLI de Azure.

  • Ejecute az version para ver la versión y las bibliotecas dependientes que están instaladas. Para actualizar a la versión más reciente, ejecute az upgrade.

• CLI de Azure versión 2.86.0 o posterior. Para buscar la versión, ejecute el az --version comando . Si necesita instalar o actualizar, consulte Install CLI de Azure.
• Si tiene varias suscripciones de Azure, seleccione el identificador de suscripción adecuado para facturar los recursos mediante el comando az account set.

• Para implementar un archivo Bicep, se necesita acceso de escritura en los recursos que crea y acceso a todas las operaciones del tipo de recurso Microsoft.Resources/deployments. Por ejemplo, para crear una máquina virtual (VM), necesita Microsoft.Compute/virtualMachines/write y Microsoft.Resources/deployments/* permisos. Para obtener una lista de roles y permisos, consulte los roles integrados de Azure.

• Instale y configure Terraform.

Creación de un grupo de recursos

Un grupo de recursos Azure es un grupo lógico en el que se implementan y administran los recursos Azure.

Cree un grupo de recursos con el comando az group create. En el ejemplo siguiente se crea un grupo de recursos denominado myResourceGroup en la ubicación canadacentral :

az group create --name myResourceGroup --location canadacentral

La salida del siguiente ejemplo es similar a la creación correcta del grupo de recursos:

{
  "id": "/subscriptions/<guid>/resourceGroups/myResourceGroup",
  "location": "canadacentral",
  "managedBy": null,
  "name": "myResourceGroup",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null
}

Crear un clúster de AKS Automatic

Cree un clúster automático de AKS usando el comando az aks create con el parámetro --sku establecido en automatic. En el ejemplo siguiente se crea un clúster denominado myAKSAutomaticCluster con Prometheus administrado y la integración de Container Insights habilitada:

az aks create \
    --resource-group myResourceGroup \
    --name myAKSAutomaticCluster \
    --sku automatic
    --enable-hosted-system

Cuando finalice el despliegue, la salida muestra una propiedad hostedSystemProfile con la propiedad enabled establecida en true. También puede ejecutar el siguiente comando para mostrar las hostedSystemProfile propiedades:

az aks show \
  --resource-group myResourceGroup \
  --name myAKSAutomaticCluster \
  --query hostedSystemProfile

{
  "enabled": true,
  "nodeSubnetId": null,
  "systemNodeSubnetId": null
}

Creación de un clúster de Kubernetes automático

1. Para crear un clúster automático de AKS, busque y seleccione Servicios de Kubernetes. Esto le lleva a la página del Centro de Kubernetes (versión preliminar).

2. En la página del Centro Kubernetes (versión preliminar), seleccione Crear>Clúster Automático de Kubernetes.

   

3. En la pestaña Aspectos básicos , rellene todos los campos necesarios (Suscripción, Grupo de recursos, Nombre del clúster de Kubernetes y Región) y, a continuación, seleccione Siguiente.

   

4. En la pestaña Monitoring, seleccione las configuraciones de supervisión deseadas en Azure Monitor (Container Insights), Prometheus administrado, Paneles de Grafana y Alertas y, después, seleccione Siguiente.

   

5. En la pestaña Advanced, seleccione las configuraciones avanzadas deseadas Acceso privado, Azure Redes virtuales, Identidad administrada, Seguridad de red de contenedor (ACNS) y Espacios de nombres de Kubernetes administrados y, a continuación, seleccione Review + create.

   

6. Revise las configuraciones de la pestaña Revisar y crear y, a continuación, seleccione Crear para implementar el clúster automático de AKS.

7. Empiece a configurar la primera aplicación desde GitHub y configure una canalización de implementación automatizada.

   

Revisión del archivo de Bicep

El siguiente archivo Bicep define un clúster automático de AKS:

@description('The name of the managed cluster resource.')
param clusterName string = 'myAKSAutomaticCluster'

@description('The location of the managed cluster resource.')
param location string = resourceGroup().location

resource aks 'Microsoft.ContainerService/managedClusters@2026-02-01' ' = {
  name: clusterName
  location: location
  sku: {
    name: 'Automatic'
  }
  identity: {
    type: 'SystemAssigned'
  }
}

Para obtener más información sobre el recurso definido en el archivo Bicep, consulte el Microsoft. ContainerService/managedClusters referencia.

Despliega el archivo Bicep

1. Guarda el archivo Bicep como main.bicep en su equipo local.

   Importante

   El archivo Bicep establece el parámetro clusterName en la cadena myAKSAutomaticCluster. Si desea usar otro nombre de clúster, asegúrese de actualizar la cadena al nombre de clúster preferido antes de guardar el archivo en el equipo.

2. Implemente el archivo Bicep mediante el comando [az deployment group create][az-deployment-group-create].

   az deployment group create --resource-group myResourceGroup --template-file main.bicep
   

   El clúster de AKS tarda unos minutos en crearse. Espere a que el clúster se implemente correctamente para pasar al siguiente paso.

Revisión del código de Terraform

1. Cree un directorio para probar el código de Terraform de ejemplo y establézcalo como directorio actual.

2. Cree un archivo denominado providers.tf e inserte el siguiente código:

   terraform {
     required_version = ">= 1.0"
     required_providers {
       azurerm = {
         source  = "hashicorp/azurerm"
         version = "~>5.0"
       }
       random = {
         source  = "hashicorp/random"
         version = "~>3.0"
       }
     }
   }
   
   provider "azurerm" {
     features {}
   }
   

3. Crea un archivo con nombre main.tf y añade el siguiente código:

   # Create a random name for the resource group using random_pet
   resource "random_pet" "rg_name" {
     prefix = var.resource_group_name_prefix
   }
   
   # Create a resource group using the generated random name
   resource "azurerm_resource_group" "rg" {
     location = var.resource_group_location
     name     = random_pet.rg_name.id
   }
   
   # Create a random name for the AKS Automatic cluster
   resource "random_pet" "cluster_name" {
     prefix = var.cluster_name_prefix
   }
   
   # Create the AKS Automatic cluster
   resource "azurerm_kubernetes_automatic_cluster" "aks_automatic" {
     name                = random_pet.cluster_name.id
     location            = azurerm_resource_group.rg.location
     resource_group_name = azurerm_resource_group.rg.name
   
     identity {
       type = "SystemAssigned"
     }
   }
   

4. Crea un archivo con nombre variables.tf y añade el siguiente código:

   variable "resource_group_location" {
     type        = string
     default     = "westus2"
     description = "Location of the resource group."
   }
   
   variable "resource_group_name_prefix" {
     type        = string
     default     = "rg"
     description = "Prefix of the resource group name that's combined with a random ID so name is unique in your Azure subscription."
   }
   
   variable "cluster_name_prefix" {
     type        = string
     default     = "aks-automatic"
     description = "Prefix of the AKS Automatic cluster name that's combined with a random ID so the name is unique in your Azure subscription."
   }
   

5. Cree un archivo denominado outputs.tf e inserte el siguiente código:

   output "resource_group_name" {
     value = azurerm_resource_group.rg.name
   }
   
   output "cluster_name" {
     value = azurerm_kubernetes_automatic_cluster.aks_automatic.name
   }
   
   output "cluster_id" {
     value = azurerm_kubernetes_automatic_cluster.aks_automatic.id
   }
   
   output "node_resource_group_id" {
     value = azurerm_kubernetes_automatic_cluster.aks_automatic.node_resource_group_id
   }
   
   output "fully_qualified_domain_name" {
     value = azurerm_kubernetes_automatic_cluster.aks_automatic.fully_qualified_domain_name
   }
   

Inicializar Terraform

Ejecute terraform init para inicializar la implementación de Terraform. Este comando descarga los proveedores de Azure necesarios para administrar los recursos de Azure.

terraform init -upgrade

Creación de un plan de ejecución de Terraform

Ejecute terraform plan para crear un plan de ejecución.

terraform plan -out main.tfplan

Aplicación de un plan de ejecución de Terraform

Ejecute terraform apply para aplicar el plan de ejecución a su infraestructura en la nube.

terraform apply main.tfplan

La creación de un clúster automático de AKS tarda varios minutos en completarse.

Comprobación del clúster

1. Obtenga el nombre del grupo de recursos de Azure y el nombre del clúster.

   resource_group_name=$(terraform output -raw resource_group_name)
   cluster_name=$(terraform output -raw cluster_name)
   

2. Ejecute az aks show para mostrar el clúster y confirme que usa la Automatic SKU.

   az aks show --resource-group $resource_group_name --name $cluster_name --query "{name:name, sku:sku, provisioningState:provisioningState}"
   

1. Configure kubectl para conectarse a su clúster de Kubernetes utilizando el comando az aks get-credentials. Con este comando se descargan las credenciales y se configura la CLI de Kubernetes para usarlas.

   az aks get-credentials --resource-group myResourceGroup --name myAKSAutomaticCluster
   

1. Configure kubectl para conectarse al clúster de Kubernetes mediante el az aks get-credentials comando . Con este comando se descargan las credenciales y se configura la CLI de Kubernetes para usarlas.

   az aks get-credentials --resource-group $resource_group_name --name $cluster_name
   

Quite el grupo de recursos, el servicio de contenedor y todos los recursos relacionados mediante el comando az group delete.

az group delete --name myResourceGroup --yes --no-wait

Cuando ya no necesite los recursos que creó con Terraform, ejecute terraform plan y especifique la opción destroy.

terraform plan -destroy -out main.destroy.tfplan

Ejecute terraform apply para aplicar el plan de ejecución.

terraform apply main.destroy.tfplan