Inicio rápido: implementación de clústeres de Azure Kubernetes Service (AKS) con Terraform

  • Artículo

Azure Kubernetes Service (AKS) es un servicio de Kubernetes administrado que le permite implementar y administrar clústeres rápidamente. En esta guía de inicio rápido:

  • Implementar un clúster de AKS con Terraform.
  • Ejecutar una aplicación de varios contenedores de ejemplo con un grupo de microservicios y front-ends web simulando un escenario comercial.

Nota:

Para empezar a aprovisionar rápidamente un clúster de AKS, en este artículo se incluyen los pasos para implementar un clúster con la configuración predeterminada solo con fines de evaluación. Antes de implementar un clúster listo para producción, se recomienda familiarizarse con nuestra arquitectura de referencia de línea de base para considerar cómo se alinea con sus requisitos empresariales.

Antes de empezar

Nota:

El grupo de nodos de Linux de Azure ya se encuentra en disponibilidad general (GA). Para obtener información sobre las ventajas y los pasos de implementación, consulte Introducción al host de contenedor de Linux en Azure para AKS.

Inicio de sesión en la cuenta de Azure

En primer lugar, inicie sesión en su cuenta de Azure y autentíquese con uno de los métodos descritos en la sección siguiente.

Escenarios de autenticación de Terraform y Azure

Terraform solo admite la autenticación en Azure a través de la CLI de Azure. No se admite la autenticación con Azure PowerShell. Por lo tanto, aunque puede usar el módulo de Azure PowerShell al realizar el trabajo de Terraform, primero debe autenticarse en Azure mediante la CLI de Azure.

En este artículo se explica cómo autenticar Terraform en Azure en los escenarios siguientes. Para más información sobre las opciones de autenticación de Terraform en Azure, consulte Autenticación mediante la CLI de Azure.

Autenticación en Azure mediante una cuenta Microsoft

Una cuenta Microsoft es un nombre de usuario (asociado a un correo electrónico y sus credenciales) que se usa para iniciar sesión en servicios de Microsoft, como Azure. Se puede asociar a una o varias suscripciones de Azure, una de las cuales es la predeterminada.

Los pasos siguientes muestran cómo:

  • Iniciar sesión en Azure de forma interactiva usando una cuenta de Microsoft
  • Enumerar las suscripciones de Azure asociadas a la cuenta (incluido el valor predeterminado)
  • Establezca la suscripción actual.

  1. Abra una línea de comandos que tenga acceso a la CLI de Azure.

  2. Ejecute az login sin parámetros y siga las instrucciones para iniciar sesión en Azure.

    az login

    Puntos clave:

    • Tras iniciar sesión correctamente, az login muestra una lista de las suscripciones de Azure asociadas a la cuenta Microsoft con la que ha iniciado sesión (se incluye la predeterminada).

  3. Para ver la suscripción actual de Azure, ejecute az account show.

    az account show

  4. Para ver todos los nombres de suscripción e identificadores de Azure de una cuenta Microsoft específica, ejecute az account list.

    az account list --query "[?user.name=='<microsoft_account_email>'].{Name:name, ID:id, Default:isDefault}" --output Table

    Puntos clave:

    • Reemplace el marcador de posición <microsoft_account_email> por la dirección de correo electrónico de la cuenta Microsoft cuyas suscripciones de Azure quiere mostrar.
    • Con una cuenta Live, como Hotmail o Outlook, puede que deba especificar la dirección de correo electrónico completa. Por ejemplo, si la dirección de correo electrónico es admin@hotmail.com, es posible que tenga que reemplazar el marcador de posición por live.com#admin@hotmail.com.

  5. Para usar una suscripción de Azure específica, ejecute az account set.

    az account set --subscription "<subscription_id_or_subscription_name>"

    Puntos clave:

    • Reemplace el marcador de posición <subscription_id_or_subscription_name> por el identificador o el nombre de la suscripción que quiere usar.
    • Una llamada a az account set no muestra los resultados del cambio a la suscripción de Azure especificada. Sin embargo, puede usar az account show para confirmar que la suscripción actual de Azure ha cambiado.
    • Si ejecuta el comando az account list del paso anterior, verá que la suscripción predeterminada de Azure ha cambiado a la suscripción que especificó con az account set.

Creación de una entidad de servicio

las herramientas automatizadas que usan los servicios de Azure, como Terraform, deberán tener siempre permisos restringidos. En lugar de que las aplicaciones inicien sesión como un usuario con todos los privilegios, Azure ofrece entidades de servicio.

El patrón más común es iniciar sesión de forma interactiva en Azure, crear una entidad de servicio, probarla y, luego, usarla en futuras autenticaciones (ya sea de forma interactiva o con los scripts).

  1. Para crear una entidad de servicio, inicie sesión en Azure. Después de autenticarse en Azure mediante una cuenta Microsoft, vuelva aquí.

  2. Si va a crear una entidad de servicio desde Git Bash, establezca la variable de entorno MSYS_NO_PATHCONV. (Este paso no es necesario si usa Cloud Shell).

    export MSYS_NO_PATHCONV=1

    Puntos clave:

    • Puede establecer la variable de entorno MSYS_NO_PATHCONV globalmente (para todas las sesiones de terminal) o localmente (solo para la sesión actual). Como la creación de una entidad de servicio no es algo que se haga con frecuencia, en el ejemplo se establece el valor de la sesión actual. Para establecer esta variable de entorno globalmente, agregue la configuración al archivo ~/.bashrc.

  3. Para crear una entidad de servicio, ejecute az ad sp create-for-rbac.

    az ad sp create-for-rbac --name <service_principal_name> --role Contributor --scopes /subscriptions/<subscription_id>

    Puntos clave:

    • Puede reemplazar <service-principal-name> por un nombre personalizado para su entorno u omitir el parámetro por completo. Si omite el parámetro, el nombre de la entidad de seguridad de servicio se genera en función de la fecha y hora actuales.
    • Una vez finalizado correctamente, az ad sp create-for-rbac muestra varios valores. En el paso siguiente se usan los valores appId, password y tenant.
    • La contraseña no se puede recuperar si se pierde. Por lo tanto, debe almacenarla en un lugar seguro. Si olvida la contraseña, puede restablecer las credenciales de la entidad de servicio.
    • En este artículo, se usa una entidad de servicio con el rol Colaborador. Para más información sobre el control de acceso basado en rol (RBAC), consulte RBAC: roles integrados.
    • La salida de la creación de la entidad de servicio incluye credenciales confidenciales. Asegúrese de no incluirlas en el código ni en el control de código fuente.
    • Para más información sobre las opciones al crear una entidad de servicio con la CLI de Azure, consulte el artículo Creación de una entidad de servicio de Azure con la CLI de Azure.

Especificar las credenciales de la entidad de servicio en las variables de entorno.

Después de crear una entidad de servicio, puede especificar sus credenciales en Terraform mediante variables de entorno.

  1. Modifique el archivo ~/.bashrc agregando las siguientes variables de entorno.

    export ARM_SUBSCRIPTION_ID="<azure_subscription_id>"
export ARM_TENANT_ID="<azure_subscription_tenant_id>"
export ARM_CLIENT_ID="<service_principal_appid>"
export ARM_CLIENT_SECRET="<service_principal_password>"

  2. Para ejecutar el script ~/.bashrc, ejecute source ~/.bashrc (o su equivalente abreviado, . ~/.bashrc). También puede salir y volver a abrir Cloud Shell para que el script se ejecute automáticamente.

    . ~/.bashrc

  3. Una vez establecidas las variables de entorno, puede comprobar sus valores de la siguiente manera:

    printenv | grep ^ARM*

Puntos clave:

  • Al igual que con cualquier variable de entorno, para acceder a un valor de suscripción de Azure desde un script de Terraform, use la sintaxis siguiente: ${env.<environment_variable>}. Por ejemplo, para acceder al valor ARM_SUBSCRIPTION_ID, especifique ${env.ARM_SUBSCRIPTION_ID}.
  • Al crear y aplicar planes de ejecución de Terraform se realizan cambios en la suscripción de Azure asociada a la entidad de servicio. A veces, este hecho puede resultar confuso si ha iniciado sesión en una suscripción de Azure y las variables de entorno apuntan a una segunda suscripción de Azure. Echemos un vistazo al ejemplo siguiente para explicarlo. Supongamos que tiene dos suscripciones de Azure: SubA y SubB. Si la suscripción actual de Azure es SubA (determinada a través de az account show) mientras que las variables de entorno apuntan a SubB, los cambios realizados por Terraform se encuentran en SubB. Por lo tanto, tendría que iniciar sesión en su suscripción SubB para ejecutar los comandos de la CLI de Azure o de Azure PowerShell y ver los cambios.

Especificar las credenciales de la entidad de servicio en un bloque de proveedor de Terraform.

El bloque de proveedor de Azure define la sintaxis que permite especificar la información de autenticación de la suscripción de Azure.

terraform {
  required_providers {
    azurerm = {
      source = "hashicorp/azurerm"
      version = "~>2.0"
    }
  }
}

provider "azurerm" {
  features {}

  subscription_id   = "<azure_subscription_id>"
  tenant_id         = "<azure_subscription_tenant_id>"
  client_id         = "<service_principal_appid>"
  client_secret     = "<service_principal_password>"
}

# Your code goes here

Precaución

La posibilidad de especificar las credenciales de suscripción de Azure en un archivo de configuración de Terraform puede resultar práctica, especialmente durante las pruebas. Sin embargo, no es aconsejable almacenar las credenciales en un archivo de texto no cifrado que puedan ver usuarios que no son de confianza.

Implementación del código de Terraform

Nota

El código de ejemplo de este artículo se encuentra en el repositorio de GitHub de Azure Terraform. Puedes ver el archivo de registro que contiene los resultados de las pruebas de las versiones actuales y anteriores de Terraform.

Consulte más artículos y código de ejemplo sobre el uso Terraform para administrar recursos de Azure.

  1. Cree un directorio que pueda usar para probar el código de ejemplo de Terraform y conviértalo en el directorio actual.

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

    terraform {
  required_version = ">=1.0"

  required_providers {
    azapi = {
      source  = "azure/azapi"
      version = "~>1.5"
    }
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~>3.0"
    }
    random = {
      source  = "hashicorp/random"
      version = "~>3.0"
    }
    time = {
      source  = "hashicorp/time"
      version = "0.9.1"
    }
  }
}

provider "azurerm" {
  features {}
}

  3. Cree un archivo denominado ssh.tf e inserte el siguiente código:

    resource "random_pet" "ssh_key_name" {
  prefix    = "ssh"
  separator = ""
}

resource "azapi_resource_action" "ssh_public_key_gen" {
  type        = "Microsoft.Compute/sshPublicKeys@2022-11-01"
  resource_id = azapi_resource.ssh_public_key.id
  action      = "generateKeyPair"
  method      = "POST"

  response_export_values = ["publicKey", "privateKey"]
}

resource "azapi_resource" "ssh_public_key" {
  type      = "Microsoft.Compute/sshPublicKeys@2022-11-01"
  name      = random_pet.ssh_key_name.id
  location  = azurerm_resource_group.rg.location
  parent_id = azurerm_resource_group.rg.id
}

output "key_data" {
  value = jsondecode(azapi_resource_action.ssh_public_key_gen.output).publicKey
}

  4. Cree un archivo denominado main.tf e inserte el siguiente código:

    # Generate random resource group name
resource "random_pet" "rg_name" {
  prefix = var.resource_group_name_prefix
}

resource "azurerm_resource_group" "rg" {
  location = var.resource_group_location
  name     = random_pet.rg_name.id
}

resource "random_pet" "azurerm_kubernetes_cluster_name" {
  prefix = "cluster"
}

resource "random_pet" "azurerm_kubernetes_cluster_dns_prefix" {
  prefix = "dns"
}

resource "azurerm_kubernetes_cluster" "k8s" {
  location            = azurerm_resource_group.rg.location
  name                = random_pet.azurerm_kubernetes_cluster_name.id
  resource_group_name = azurerm_resource_group.rg.name
  dns_prefix          = random_pet.azurerm_kubernetes_cluster_dns_prefix.id

  identity {
    type = "SystemAssigned"
  }

  default_node_pool {
    name       = "agentpool"
    vm_size    = "Standard_D2_v2"
    node_count = var.node_count
  }
  linux_profile {
    admin_username = var.username

    ssh_key {
      key_data = jsondecode(azapi_resource_action.ssh_public_key_gen.output).publicKey
    }
  }
  network_profile {
    network_plugin    = "kubenet"
    load_balancer_sku = "standard"
  }
}

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

    variable "resource_group_location" {
  type        = string
  default     = "eastus"
  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 "node_count" {
  type        = number
  description = "The initial quantity of nodes for the node pool."
  default     = 3
}

variable "msi_id" {
  type        = string
  description = "The Managed Service Identity ID. Set this value if you're running this example using Managed Identity as the authentication method."
  default     = null
}

variable "username" {
  type        = string
  description = "The admin username for the new cluster."
  default     = "azureadmin"
}

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

    output "resource_group_name" {
  value = azurerm_resource_group.rg.name
}

output "kubernetes_cluster_name" {
  value = azurerm_kubernetes_cluster.k8s.name
}

output "client_certificate" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].client_certificate
  sensitive = true
}

output "client_key" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].client_key
  sensitive = true
}

output "cluster_ca_certificate" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].cluster_ca_certificate
  sensitive = true
}

output "cluster_password" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].password
  sensitive = true
}

output "cluster_username" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].username
  sensitive = true
}

output "host" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].host
  sensitive = true
}

output "kube_config" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config_raw
  sensitive = true
}

Inicialización de Terraform

Para inicializar la implementación de Terraform, ejecute terraform init. Este comando descarga el proveedor de Azure necesario para administrar los recursos de Azure.

terraform init -upgrade

Puntos clave:

  • El parámetro -upgrade actualiza los complementos de proveedor necesarios a la versión más reciente que cumpla con las restricciones de versión de la configuración.

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

Puntos clave:

  • El comando terraform plan crea un plan de ejecución, pero no lo ejecuta. En su lugar, determina qué acciones son necesarias para crear la configuración especificada en los archivos de configuración. Este patrón le permite comprobar si el plan de ejecución coincide con sus expectativas antes de realizar cambios en los recursos reales.
  • El parámetro -out opcional permite especificar un archivo de salida para el plan. El uso del parámetro -out garantiza que el plan que ha revisado es exactamente lo que se aplica.

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

Puntos clave:

  • El comando terraform apply de ejemplo asume que ejecutó terraform plan -out main.tfplan previamente.
  • Si especificó un nombre de archivo diferente para el parámetro -out, use ese mismo nombre de archivo en la llamada a terraform apply.
  • Si no ha utilizado el parámetro -out, llame a terraform apply sin ningún parámetro.

Verificación de los resultados

  1. Obtenga el nombre del grupo de recursos de Azure con el siguiente comando.

    resource_group_name=$(terraform output -raw resource_group_name)

  2. Muestre el nombre del nuevo clúster de Kubernetes con el comando az aks list.

    az aks list \
  --resource-group $resource_group_name \
  --query "[].{\"K8s cluster name\":name}" \
  --output table

  3. Obtenga la configuración de Kubernetes del estado de Terraform y almacénela en un archivo que kubectl pueda leer con el siguiente comando.

    echo "$(terraform output kube_config)" > ./azurek8s

  4. Verifique que el comando anterior no haya agregado un carácter ASCII EOT usando el siguiente comando .

    cat ./azurek8s

    Puntos clave:

    • Si viera << EOT al principio y EOT al final, quite estos caracteres del archivo. En caso contrario, es posible que reciba el siguiente mensaje de error: error: error loading config file "./azurek8s": yaml: line 2: mapping values are not allowed in this context

  5. Establezca una variable de entorno para que kubectlseleccione la configuración correcta con el siguiente comando.

    export KUBECONFIG=./azurek8s

  6. Compruebe el estado del clúster mediante el comando kubectl get nodes.

    kubectl get nodes

Puntos clave:

  • Cuando creó el clúster de AKS, se habilitó la supervisión para capturar métricas de mantenimiento para los nodos y pods del clúster. Estas métricas de mantenimiento están disponibles en Azure Portal. Para obtener más información sobre la supervisión del estado de los contenedores, consulte Monitor Azure Kubernetes Service health (Supervisión del estado de Azure Kubernetes Service).
  • Varios valores de clave se clasificaron como salida cuando aplicó el plan de ejecución de Terraform. Por ejemplo, la dirección de host, el nombre de usuario del clúster de AKS y la contraseña del clúster de AKS son la salida.

Implementación de la aplicación

Para implementar la aplicación, se usa un archivo de manifiesto para crear todos los objetos necesarios para ejecutar la aplicación AKS Store. Un archivo de manifiesto de Kubernetes define el estado deseado del clúster, por ejemplo, qué imágenes de contenedor se van a ejecutar. El manifiesto incluye las siguientes implementaciones y servicios de Kubernetes:

Captura de pantalla de la arquitectura de ejemplo de Azure Store.

  • Escaparate: aplicación web para que los clientes vean productos y realicen pedidos.
  • Servicio de producto: muestra información del producto.
  • Servicio de pedidos: realiza pedidos.
  • Rabbit MQ: cola de mensajes para una cola de pedidos.

Nota:

No se recomienda ejecutar contenedores con estado, como Rabbit MQ, sin almacenamiento persistente para producción. Estos se usan aquí para simplificar, pero se recomienda usar servicios administrados, como Azure CosmosDB o Azure Service Bus.

  1. Cree un archivo denominado aks-store-quickstart.yaml y cópielo en el siguiente manifiesto:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: rabbitmq
spec:
  replicas: 1
  selector:
    matchLabels:
      app: rabbitmq
  template:
    metadata:
      labels:
        app: rabbitmq
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
      - name: rabbitmq
        image: mcr.microsoft.com/mirror/docker/library/rabbitmq:3.10-management-alpine
        ports:
        - containerPort: 5672
          name: rabbitmq-amqp
        - containerPort: 15672
          name: rabbitmq-http
        env:
        - name: RABBITMQ_DEFAULT_USER
          value: "username"
        - name: RABBITMQ_DEFAULT_PASS
          value: "password"
        resources:
          requests:
            cpu: 10m
            memory: 128Mi
          limits:
            cpu: 250m
            memory: 256Mi
        volumeMounts:
        - name: rabbitmq-enabled-plugins
          mountPath: /etc/rabbitmq/enabled_plugins
          subPath: enabled_plugins
      volumes:
      - name: rabbitmq-enabled-plugins
        configMap:
          name: rabbitmq-enabled-plugins
          items:
          - key: rabbitmq_enabled_plugins
            path: enabled_plugins
---
apiVersion: v1
data:
  rabbitmq_enabled_plugins: |
    [rabbitmq_management,rabbitmq_prometheus,rabbitmq_amqp1_0].
kind: ConfigMap
metadata:
  name: rabbitmq-enabled-plugins            
---
apiVersion: v1
kind: Service
metadata:
  name: rabbitmq
spec:
  selector:
    app: rabbitmq
  ports:
    - name: rabbitmq-amqp
      port: 5672
      targetPort: 5672
    - name: rabbitmq-http
      port: 15672
      targetPort: 15672
  type: ClusterIP
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: order-service
spec:
  replicas: 1
  selector:
    matchLabels:
      app: order-service
  template:
    metadata:
      labels:
        app: order-service
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
      - name: order-service
        image: ghcr.io/azure-samples/aks-store-demo/order-service:latest
        ports:
        - containerPort: 3000
        env:
        - name: ORDER_QUEUE_HOSTNAME
          value: "rabbitmq"
        - name: ORDER_QUEUE_PORT
          value: "5672"
        - name: ORDER_QUEUE_USERNAME
          value: "username"
        - name: ORDER_QUEUE_PASSWORD
          value: "password"
        - name: ORDER_QUEUE_NAME
          value: "orders"
        - name: FASTIFY_ADDRESS
          value: "0.0.0.0"
        resources:
          requests:
            cpu: 1m
            memory: 50Mi
          limits:
            cpu: 75m
            memory: 128Mi
      initContainers:
      - name: wait-for-rabbitmq
        image: busybox
        command: ['sh', '-c', 'until nc -zv rabbitmq 5672; do echo waiting for rabbitmq; sleep 2; done;']
        resources:
          requests:
            cpu: 1m
            memory: 50Mi
          limits:
            cpu: 75m
            memory: 128Mi    
---
apiVersion: v1
kind: Service
metadata:
  name: order-service
spec:
  type: ClusterIP
  ports:
  - name: http
    port: 3000
    targetPort: 3000
  selector:
    app: order-service
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: product-service
spec:
  replicas: 1
  selector:
    matchLabels:
      app: product-service
  template:
    metadata:
      labels:
        app: product-service
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
      - name: product-service
        image: ghcr.io/azure-samples/aks-store-demo/product-service:latest
        ports:
        - containerPort: 3002
        resources:
          requests:
            cpu: 1m
            memory: 1Mi
          limits:
            cpu: 1m
            memory: 7Mi
---
apiVersion: v1
kind: Service
metadata:
  name: product-service
spec:
  type: ClusterIP
  ports:
  - name: http
    port: 3002
    targetPort: 3002
  selector:
    app: product-service
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: store-front
spec:
  replicas: 1
  selector:
    matchLabels:
      app: store-front
  template:
    metadata:
      labels:
        app: store-front
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
      - name: store-front
        image: ghcr.io/azure-samples/aks-store-demo/store-front:latest
        ports:
        - containerPort: 8080
          name: store-front
        env: 
        - name: VUE_APP_ORDER_SERVICE_URL
          value: "http://order-service:3000/"
        - name: VUE_APP_PRODUCT_SERVICE_URL
          value: "http://product-service:3002/"
        resources:
          requests:
            cpu: 1m
            memory: 200Mi
          limits:
            cpu: 1000m
            memory: 512Mi
---
apiVersion: v1
kind: Service
metadata:
  name: store-front
spec:
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: store-front
  type: LoadBalancer

    Para obtener un desglose de los archivos de manifiesto de YAML, consulte Implementaciones y manifiestos de YAML.

    Si crea y guarda el archivo YAML localmente, para cargar el archivo de manifiesto en el directorio predeterminado de CloudShell, seleccione el botón Cargar y descargar archivos y elija el archivo en el sistema de archivos local.

  2. Implemente la aplicación mediante el comando kubectl apply y especifique el nombre del manifiesto de YAML.

    kubectl apply -f aks-store-quickstart.yaml

    La salida del siguiente ejemplo muestra las implementaciones y los servicios creados correctamente:

    deployment.apps/rabbitmq created
service/rabbitmq created
deployment.apps/order-service created
service/order-service created
deployment.apps/product-service created
service/product-service created
deployment.apps/store-front created
service/store-front created

Prueba de la aplicación

Cuando se ejecuta la aplicación, un servicio de Kubernetes expone el front-end de la aplicación a Internet. Este proceso puede tardar unos minutos en completarse.

  1. Compruebe el estado de los pods implementados con el comando kubectl get pods. Haga que todos los pods tengan el estado Running antes de continuar.

    kubectl get pods

  2. Compruebe si hay una dirección IP pública para la aplicación de escaparate (store-front). Para supervisar el progreso, utilice el comando kubectl get service con el argumento --watch.

    kubectl get service store-front --watch

    La salida de EXTERNAL-IP del servicio store-front aparece inicialmente como pending (pendiente):

    NAME          TYPE           CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE
store-front   LoadBalancer   10.0.100.10   <pending>     80:30025/TCP   4h4m

  3. Una vez que la dirección EXTERNAL-IP cambia de pendiente a una dirección IP pública real, use CTRL-C para detener el kubectl proceso de inspección.

    En la salida del ejemplo siguiente se muestra una dirección IP pública válida asignada al servicio:

    NAME          TYPE           CLUSTER-IP    EXTERNAL-IP    PORT(S)        AGE
store-front   LoadBalancer   10.0.100.10   20.62.159.19   80:30025/TCP   4h5m

  4. Abra un explorador web en la dirección IP externa del servicio para ver la aplicación Azure Store en acción.

    Captura de pantalla de la aplicación de ejemplo de la Tienda AKS.

Limpieza de recursos

Eliminación de recursos de AKS

Cuando ya no necesite los recursos creados a través de Terraform, realice los pasos siguientes:

  1. Ejecute el comando terraform plan y especifique la marca destroy.

    terraform plan -destroy -out main.destroy.tfplan

    Puntos clave:

    • El comando terraform plan crea un plan de ejecución, pero no lo ejecuta. En su lugar, determina qué acciones son necesarias para crear la configuración especificada en los archivos de configuración. Este patrón le permite comprobar si el plan de ejecución coincide con sus expectativas antes de realizar cambios en los recursos reales.
    • El parámetro -out opcional permite especificar un archivo de salida para el plan. El uso del parámetro -out garantiza que el plan que ha revisado es exactamente lo que se aplica.

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

    terraform apply main.destroy.tfplan

Eliminación de la entidad de servicio

  1. Obtenga el identificador de la entidad de servicio con el siguiente comando.

    sp=$(terraform output -raw sp)

  2. Elimine la entidad de servicio con el comando az ad sp delete.

    az ad sp delete --id $sp

Clonación de la plantilla de Azure Developer CLI

Azure Developer CLI permite descargar rápidamente ejemplos del repositorio Azure-Samples. En el inicio rápido, descargará la aplicación aks-store-demo. Para obtener más información sobre los casos de uso generales, consulte la azd información general.

  1. Clona la plantilla de demostración de la Tienda AKS del repositorio Azure-Samples mediante el comando azd init con el parámetro --template.

    azd init --template Azure-Samples/aks-store-demo

  2. Escriba un nombre de entorno para el proyecto que solo tenga caracteres alfanuméricos y guiones, como aks-terraform-1.

    Enter a new environment name: aks-terraform-1

Inicie sesión en la cuenta de Azure Cloud.

La plantilla de azd contiene todo el código necesario para crear los servicios, pero debes iniciar sesión en la cuenta de Azure a fin de hospedar la aplicación en AKS.

  1. Inicia sesión en tu cuenta mediante el comando azd auth login.

    azd auth login

  2. Copia el código del dispositivo que aparece en la salida y presiona Entrar para iniciar sesión.

    Start by copying the next code: XXXXXXXXX
Then press enter and continue to log in from your browser...

    Importante

    Si usas una máquina virtual fuera de red o un codespace de GitHub, determinadas directivas de seguridad de Azure provocan conflictos cuando se usan para iniciar sesión con azd auth login. Si se produjese un problema aquí, siga la solución alternativa azd auth proporcionada, lo que implicará el uso de una solicitud curl a la dirección URL de localhost a la que se redirigió después de ejecutar azd auth login.

  3. Autentícate con tus credenciales en la página de inicio de sesión de la organización.

  4. Confirma que estás intentando conectarte desde la CLI de Azure.

  5. Compruebe que el mensaje "Autenticación de código de dispositivo completada. Ha iniciado sesión en Azure." aparece en el terminal original.

    Waiting for you to complete authentication in the browser...
Device code authentication completed.
Logged in to Azure.

Solución alternativa azd auth

Esta solución alternativa requiere que tengas instalada la CLI de Azure.

  1. Abre una ventana de terminal e inicia sesión con la CLI de Azure mediante el comando az login con el parámetro --scope establecido en https://graph.microsoft.com/.default.

    az login --scope https://graph.microsoft.com/.default

    Debes redirigirte a una página de autenticación en una nueva pestaña para crear un token de acceso del explorador, como se muestra en el ejemplo siguiente:

    https://login.microsoftonline.com/organizations/oauth2/v2.0/authorize?clientid=<your_client_id>.

  2. Copia la dirección URL de localhost de la página web que recibiste después de intentar iniciar sesión con azd auth login.

  3. En una nueva ventana de terminal, usa la siguiente solicitud curl para iniciar sesión. Asegúrate de reemplazar el marcador de posición <localhost> por la dirección URL de localhost que copiaste en el paso anterior.

    curl <localhost>

    Un inicio de sesión correcto genera una página web HTML, como se muestra en el ejemplo siguiente:

    <!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <meta http-equiv="refresh" content="60;url=https://docs.microsoft.com/cli/azure/">
    <title>Login successfully</title>
    <style>
        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
        }

        code {
            font-family: Consolas, 'Liberation Mono', Menlo, Courier, monospace;
            display: inline-block;
            background-color: rgb(242, 242, 242);
            padding: 12px 16px;
            margin: 8px 0px;
        }
    </style>
</head>
<body>
    <h3>You have logged into Microsoft Azure!</h3>
    <p>You can close this window, or we will redirect you to the <a href="https://docs.microsoft.com/cli/azure/">Azure CLI documentation</a> in 1 minute.</p>
    <h3>Announcements</h3>
    <p>[Windows only] Azure CLI is collecting feedback on using the <a href="https://learn.microsoft.com/windows/uwp/security/web-account-manager">Web Account Manager</a> (WAM) broker for the login experience.</p>
    <p>You may opt-in to use WAM by running the following commands:</p>
    <code>
        az config set core.allow_broker=true<br>
        az account clear<br>
        az login
    </code>
</body>
</html>

  4. Cierra el terminal actual y abre el terminal original. Deberías ver una lista JSON de las suscripciones.

  5. Copia el campo id de la suscripción que quieres usar.

  6. Establece la suscripción ejecutando el comando az account set.

    az account set --subscription <subscription_id>

Creación e implementación de recursos para el clúster

Para implementar la aplicación, use el comando azd up para crear todos los objetos necesarios para ejecutar la aplicación AKS Store.

  • Un archivo azure.yaml define el estado deseado de un clúster, como las imágenes de contenedor que se vayan a capturar, e incluye las siguientes implementaciones y servicios de Kubernetes:

Diagrama que muestra la arquitectura de ejemplo de Azure Store.

  • Escaparate: aplicación web para que los clientes vean productos y realicen pedidos.
  • Servicio de producto: muestra información del producto.
  • Servicio de pedidos: realiza pedidos.
  • Rabbit MQ: cola de mensajes para una cola de pedidos.

Nota:

No se recomienda ejecutar contenedores con estado, como Rabbit MQ, sin almacenamiento persistente para producción. Estos se usan aquí para simplificar, pero se recomienda usar servicios administrados, como Azure Cosmos DB o Azure Service Bus.

Implementación de recursos de aplicación

La plantilla de azd para esta guía de inicio rápido crea un grupo de recursos nuevo con un clúster de AKS y una instancia de Azure Key Vault. El almacén de claves almacena los secretos de cliente y ejecuta los servicios en el espacio de nombres pets.

  1. Crea todos los recursos de la aplicación mediante el comando azd up.

    azd up

    azd up ejecuta todos los enlaces dentro de la carpeta azd-hooks para registrar previamente, aprovisionar e implementar los servicios de aplicación.

    Personalice los enlaces para agregar código personalizado a las fases de flujo de trabajo de azd. Para obtener más información, consulte la referencia de azd enlaces.

  2. Selecciona una suscripción de Azure para el uso de facturación.

    ? Select an Azure Subscription to use:  [Use arrows to move, type to filter]
> 1. My Azure Subscription (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)

  3. Selecciona una región en la que quieras implementar la aplicación.

    Select an Azure location to use:  [Use arrows to move, type to filter]
  1.  (South America) Brazil Southeast (brazilsoutheast)
  2.  (US) Central US (centralus)
  3.  (US) East US (eastus)
> 43. (US) East US 2 (eastus2)
  4.  (US) East US STG (eastusstg)
  5.  (US) North Central US (northcentralus)
  6.  (US) South Central US (southcentralus)

    azd ejecuta automáticamente los enlaces de aprovisionamiento previo y aprovisionamiento posterior para crear los recursos de la aplicación. Este proceso puede tardar unos minutos en completarse. Una vez completado, deberías ver una salida similar al ejemplo siguiente:

    SUCCESS: Your workflow to provision and deploy to Azure completed in 9 minutes 40 seconds.

Generación de planes de Terraform

Dentro de la plantilla de Azure Developer, la carpeta /infra/terraform contiene todo el código usado para generar el plan de Terraform.

Terraform implementa y ejecuta comandos mediante terraform apply como parte del paso de aprovisionamiento de azd. Una vez completado, deberías ver una salida similar al ejemplo siguiente:

Plan: 5 to add, 0 to change, 0 to destroy.
...
Saved the plan to: /workspaces/aks-store-demo/.azure/aks-terraform-azd/infra/terraform/main.tfplan

Prueba de la aplicación

Cuando se ejecuta la aplicación, un servicio de Kubernetes expone el front-end de la aplicación a Internet. Este proceso puede tardar unos minutos en completarse.

  1. Establece el espacio de nombres como espacio de nombres de demostración pets con el comando kubectl set-context.

    kubectl config set-context --current --namespace=pets

  2. Compruebe el estado de los pods implementados con el comando kubectl get pods. Asegúrate de que todos los pods tengan el estado Running antes de continuar.

    kubectl get pods

  3. Comprueba si hay una IP pública para la aplicación de escaparate y supervisa el progreso mediante el comando kubectl get service con el argumento --watch.

    kubectl get service store-front --watch

    La salida de EXTERNAL-IP del servicio store-front aparece inicialmente como pending (pendiente):

    NAME          TYPE           CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE
store-front   LoadBalancer   10.0.100.10   <pending>     80:30025/TCP   4h4m

  4. Una vez que la dirección EXTERNAL-IP cambia de pendiente a una dirección IP pública real, use CTRL-C para detener el kubectl proceso de inspección.

    En la salida del ejemplo siguiente se muestra una dirección IP pública válida asignada al servicio:

    NAME          TYPE           CLUSTER-IP    EXTERNAL-IP    PORT(S)        AGE
store-front   LoadBalancer   10.0.100.10   20.62.159.19   80:30025/TCP   4h5m

  5. Abra un explorador web en la dirección IP externa del servicio para ver la aplicación Azure Store en acción.

    Captura de pantalla de la aplicación de ejemplo de la Tienda AKS.

Eliminación del clúster

Cuando hayas terminado con el inicio rápido, limpia todos los recursos innecesarios para evitar cargos de Azure.

  1. Elimine todos los recursos creados en el inicio rápido mediante el comando azd down.

    azd down

  2. Confirma la decisión de quitar todos los recursos usados de la suscripción; para ello, escribe y y presiona Enter.

    ? Total resources to delete: 14, are you sure you want to continue? (y/N)

  3. Permite una purga para reutilizar las variables de inicio rápido, si procede; para ello, escribe y y presiona Enter.

    [Warning]: These resources have soft delete enabled allowing them to be recovered for a period or time after deletion. During this period, their names can't be reused. In the future, you can use the argument --purge to skip this confirmation.

Solución de problemas de Terraform en Azure

Solución de problemas comunes al usar Terraform en Azure.

Pasos siguientes

En este inicio rápido, ha implementado un clúster de Kubernetes y luego ha implementado en él una aplicación simple de varios contenedores. Esta aplicación de ejemplo es solo para fines de demostración y no representa todos los procedimientos recomendados para las aplicaciones de Kubernetes. Para instrucciones sobre cómo crear soluciones completas con AKS para producción, consulte Guía de soluciones de AKS.

Para obtener más información sobre AKS y un ejemplo completo desde el código hasta la implementación, continúe con el tutorial del clúster de Kubernetes.

Más información sobre el uso de AKS.