Inicio rápido: Implementación de un clúster de Azure Kubernetes Service (AKS) mediante Terraform

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 base para considerar cómo se alinea con sus requisitos empresariales.

Antes de empezar

Nota:

El grupo de nodos de Linux en Azure ahora está disponible con carácter 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

  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.
  • Para más información acerca de la seguridad y conservar los planes de ejecución, consulte la sección Advertencia de seguridad.

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 mediante 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:

Screenshot of Azure Store sample architecture.

  • 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.

    Screenshot of AKS Store sample application.

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.
    • Para más información acerca de la seguridad y conservar los planes de ejecución, consulte la sección Advertencia de seguridad.
  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 mediante el comando az ad sp delete .

    az ad sp delete --id $sp
    

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 solo tiene 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.