Inicio rápido: implementación de un clúster de Azure Kubernetes Service (AKS) mediante la extensión de Kubernetes de Bicep (versión preliminar)

Artículo
08/08/2024

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 la extensión de Kubernetes de Bicep (versión preliminar).
Ejecutar una aplicación de varios contenedores de ejemplo con un grupo de microservicios y front-ends web simulando un escenario comercial.

Importante

La extensión de Kubernetes de Bicep está actualmente en versión preliminar. Puede habilitar la característica desde el Archivo de configuración de Bicep agregando:

{
 "experimentalFeaturesEnabled": {
   "extensibility": true,
 }
}

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

En esta guía rápida se presupone un conocimiento básico de los conceptos de Kubernetes. Para más información, consulte Conceptos básicos de Kubernetes de Azure Kubernetes Service (AKS).

Si no tiene una suscripción a Azure, cree una cuenta gratuita de Azure antes de empezar.
Asegúrese de que la identidad que usa para crear el clúster tiene los permisos mínimos adecuados. Para más información sobre el acceso y la identidad en AKS, consulte Opciones de acceso e identidad en Azure Kubernetes Service (AKS).

Bicep es un lenguaje específico de dominio (DSL) que usa una sintaxis declarativa para implementar recursos de Azure. Brinda sintaxis concisa, seguridad de tipos confiable y compatibilidad con la reutilización de código. Bicep ofrece la mejor experiencia de creación para sus soluciones de infraestructura como código en Azure.

A fin de configurar el entorno para el desarrollo de Bicep, consulte Instalación de las herramientas de Bicep. Después de realizar esos pasos, tiene Visual Studio Code y la extensión de Bicep. También tiene la versión más reciente de la CLI de Azure o del módulo Azure PowerShell.
Para crear un clúster de AKS con un archivo Bicep, debe proporcionar una clave pública SSH. Si necesita este recurso, consulte la siguiente sección. De lo contrario, vaya a Revisión del archivo de Bicep.
Para implementar un archivo Bicep, se necesita acceso de escritura en los recursos que implementa y acceso a todas las operaciones del tipo de recurso Microsoft.Resources/deployments. Por ejemplo, para implementar una máquina virtual, necesita los permisos Microsoft.Compute/virtualMachines/write y Microsoft.Resources/deployments/*. Para obtener una lista de roles y permisos, consulte Roles integrados de Azure.

Creación de un par de claves SSH

Vaya a https://shell.azure.com para abrir Cloud Shell en el explorador.

Cree un par de claves SSH mediante el comando de la CLI de Azure az sshkey create o el comando ssh-keygen.

# Create an SSH key pair using Azure CLI
az sshkey create --name "mySSHKey" --resource-group "myResourceGroup"

# Create an SSH key pair using ssh-keygen
ssh-keygen -t rsa -b 4096

Para más información sobre cómo crear claves SSH, consulte el artículo sobre Creación y administración de claves SSH para la autenticación en Azure.

Revisión del archivo de Bicep

El archivo de Bicep que se usa para crear un clúster de AKS procede de Plantillas de inicio rápido de Azure. Para ver más ejemplos de AKS, consulte las plantillas de inicio rápido de AKS.

@description('The name of the Managed Cluster resource.')
param clusterName string = 'aks101cluster'

@description('The location of the Managed Cluster resource.')
param location string = resourceGroup().location

@description('Optional DNS prefix to use with hosted Kubernetes API server FQDN.')
param dnsPrefix string

@description('Disk size (in GB) to provision for each of the agent pool nodes. This value ranges from 0 to 1023. Specifying 0 will apply the default disk size for that agentVMSize.')
@minValue(0)
@maxValue(1023)
param osDiskSizeGB int = 0

@description('The number of nodes for the cluster.')
@minValue(1)
@maxValue(50)
param agentCount int = 3

@description('The size of the Virtual Machine.')
param agentVMSize string = 'standard_d2s_v3'

@description('User name for the Linux Virtual Machines.')
param linuxAdminUsername string

@description('Configure all linux machines with the SSH RSA public key string. Your key should include three parts, for example \'ssh-rsa AAAAB...snip...UcyupgH azureuser@linuxvm\'')
param sshRSAPublicKey string

resource aks 'Microsoft.ContainerService/managedClusters@2024-02-01' = {
  name: clusterName
  location: location
  identity: {
    type: 'SystemAssigned'
  }
  properties: {
    dnsPrefix: dnsPrefix
    agentPoolProfiles: [
      {
        name: 'agentpool'
        osDiskSizeGB: osDiskSizeGB
        count: agentCount
        vmSize: agentVMSize
        osType: 'Linux'
        mode: 'System'
      }
    ]
    linuxProfile: {
      adminUsername: linuxAdminUsername
      ssh: {
        publicKeys: [
          {
            keyData: sshRSAPublicKey
          }
        ]
      }
    }
  }
}

output controlPlaneFQDN string = aks.properties.fqdn

El recurso definido en el archivo Bicep es Microsoft.ContainerService/managedClusters.

Guarde una copia del archivo como main.bicep en el equipo local.

Agregue la definició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:

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.

Cree un archivo denominado aks-store-quickstart.yaml en la misma carpeta que main.bicep y copie 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.

Abra main.bicep en Visual Studio Code.
Presione CTRL+MAYÚS+P para abrir la Paleta de comando.
Busque bicep y, a continuación, seleccione Bicep: Importar manifiesto de Kubernetes.
Seleccione aks-store-quickstart.yaml en el símbolo del sistema. Este proceso crea un archivo aks-store-quickstart.bicep en la misma carpeta.

Abra main.bicep y agregue el siguiente código de Bicep al final del archivo para hacer referencia al módulo aks-store-quickstart.bicep recién creado:

module kubernetes './aks-store-quickstart.bicep' = {
  name: 'buildbicep-deploy'
  params: {
    kubeConfig: aks.listClusterAdminCredential().kubeconfigs[0].value
  }
}

Guarde main.bicep y aks-store-quickstart.bicep.

Cree un grupo de recursos de Azure con el comando az group create.
```
az group create --name myResourceGroup --location eastus
```

Implemente la plantilla con el comando az deployment group create.

az deployment group create --resource-group myResourceGroup --template-file main.bicep --parameters clusterName=<cluster-name> dnsPrefix=<dns-previs> linuxAdminUsername=<linux-admin-username> sshRSAPublicKey='<ssh-key>'

Cree un grupo de recursos de Azure con el cmdlet New-AzResourceGroup.
```
New-AzResourceGroup -Name myResourceGroup -Location eastus
```

Implemente el archivo de Bicep mediante el cmdlet New-AzResourceGroupDeployment.

New-AzResourceGroupDeployment -ResourceGroupName myResourceGroup -TemplateFile ./main.bicep -clusterName=<cluster-name> -dnsPrefix=<dns-prefix> -linuxAdminUsername=<linux-admin-username> -sshRSAPublicKey="<ssh-key>"

Proporcione los valores siguientes en los comandos:

Nombre del clúster: escriba un nombre único para el clúster de AKS, como myAKSCluster.
Prefijo de DNS: escriba un prefijo DNS único para el clúster, como myakscluster.
Linux Admin Username (Nombre de usuario administrador de Linux): escriba un nombre de usuario para conectarse mediante SSH, como azureuser.
SSH RSA Public Key (Clave pública SSH RSA): copie y pegue la parte pública del par de claves SSH (de forma predeterminada, el contenido de ~/.ssh/id_rsa.pub).

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

Validación de la implementación de Bicep

Inicie sesión en Azure Portal.
En el menú de Azure Portal o en la página Inicio, vaya al clúster de AKS.
En Recursos de Kubernetes, seleccione Servicios y entradas.
Busque el servicio store-front y copie el valor de IP externa.
Abra un explorador web en la dirección IP externa del servicio para ver la aplicación Azure Store en acción.

Eliminación del clúster

Si no tiene previsto seguir el tutorial de AKS, limpie los recursos innecesarios para evitar cargos de Azure.

CLI de Azure
Azure PowerShell

Elimine el grupo de recursos, el servicio de contenedor y todos los recursos relacionados, para lo que debe usar el comando az group delete.

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

Quite el grupo de recursos, el servicio de contenedor y todos los recursos relacionados mediante el cmdlet Remove-AzResourceGroup.

Remove-AzResourceGroup -Name myResourceGroup

Nota:

El clúster de AKS se creó con una identidad administrada asignada por el sistema, que es la opción de identidad predeterminada utilizada en este inicio rápido. La plataforma administra esta identidad para que no tenga que quitarla manualmente.

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.

Tutorial de AKS

Compartir a través de

Inicio rápido: implementación de un clúster de Azure Kubernetes Service (AKS) mediante la extensión de Kubernetes de Bicep (versión preliminar)

Antes de empezar

Creación de un par de claves SSH

Revisión del archivo de Bicep

Agregue la definición de la aplicación.

Implementación del archivo de Bicep

Validación de la implementación de Bicep

Eliminación del clúster

Pasos siguientes

Recursos adicionales