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

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:

  • Implementación de un clúster de AKS en Azure Portal.
  • Ejecute 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

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

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.

Creación de un clúster de AKS

  1. Inicie sesión en Azure Portal.

  2. En la página principal de Azure Portal, seleccione Crear un recurso.

  3. En la sección Categorías, seleccione Contenedores>Azure Kubernetes Service (AKS).

  4. En la pestaña Información básica, configure las siguientes opciones:

    • En Detalles del proyecto:
      • Seleccione una suscripción de Azure.
      • Cree un Grupo de recursos de Azure, como myResourceGroup. Aunque puede seleccionar un grupo de recursos existente, con fines de prueba o evaluación, se recomienda crear un grupo de recursos para hospedar temporalmente estos recursos y evitar que afecte a las cargas de trabajo de producción o desarrollo.
    • En Detalles del clúster:
      • Establezca la Configuración preestablecida del clúster en Desarrollo/pruebas. Para obtener más información sobre las configuraciones preestablecidas, vea Valores preestablecidos de configuración de clúster en Azure Portal.

        Nota:

        Puede cambiar la configuración preestablecida al crear el clúster mediante la selección de Comparación de configuraciones preestablecidas y la elección de otra opción. Screenshot of Create AKS cluster - portal preset options.

      • Escriba un Nombre del clúster de Kubernetes, como myAKSCluster.

      • Seleccione una Región para el clúster de AKS.

      • Establezca el valor Zonas de disponibilidad en Ninguno.

      • Establezca Plan de tarifa de AKS en Gratis.

      • Deje el valor predeterminado seleccionado para la versión de Kubernetes.

      • Deje Actualización automática establecido en el valor recomendado, que es Habilitado con la revisión.

      • Deje el valor Autenticación y autorización establecido en Cuentas locales con RBAC de Kubernetes.

        Screenshot showing how to configure an AKS cluster in Azure portal.

  5. Seleccione Siguiente. En la pestaña Grupos de nodos, agregue un nuevo grupo de nodos:

    • Seleccione Agregar grupo de nodos.

    • Escriba un Nombre de grupo de nodos, por ejemplo, nplinux.

    • En Modo, seleccione Usuario.

    • En SKU del sistema operativo, seleccione Ubuntu Linux.

    • Establezca el valor Zonas de disponibilidad en Ninguno.

    • Deje desactivada la casilla Habilitar instancias de Azure Spot.

    • En Tamaño de nodo, seleccione Elección de un tamaño. En la página Seleccionar un tamaño de máquina virtual, seleccione D2s_v3y elija el botón Seleccionar.

    • Deje el valor Método de escalado establecido en Escalado automático.

    • Deje los campos Número mínimo de nodos y Número máximo de nodos establecidos en su valor predeterminado.

      Screenshot showing how to create a node pool running Ubuntu Linux.

  6. Deje todas las opciones de configuración en las demás pestañas establecidas en sus valores predeterminados, excepto la configuración de la pestaña Supervisión. De forma predeterminada, las características de Azure Monitor, Container Insights, el servicio administrado de Azure Monitor para Prometheus y Azure Managed Grafana están habilitados. Si los deshabilita, puede ahorrar costos.

  7. Seleccione Revisar y crear para ejecutar la validación en la configuración del clúster. Una vez finalizada la validación, seleccione Crear para crear un grupo de AKS.

El clúster de AKS tarda unos minutos en crearse. Una vez finalizada la implementación, vaya al recurso; puede hacerlo de dos maneras:

  • Seleccione Ir al recurso.
  • Vaya al grupo de recursos del clúster de AKS y seleccione el recurso de AKS. En este ejemplo, busque myResourceGroup y seleccione el recurso myAKSCluster.

Conectarse al clúster

Para administrar un clúster de Kubernetes, use kubectl, el cliente de línea de comandos de Kubernetes. Si usa Azure Cloud Shell, kubectl ya está instalado. Si no está familiarizado con Cloud Shell, consulte Introducción a Azure Cloud Shell.

Si usa Cloud Shell, ábralo con el botón >_ en la parte superior de Azure Portal. Si usa PowerShell localmente, conéctese a Azure mediante el comando Connect-AzAccount. Si usa la CLI de Azure localmente, conéctese a Azure mediante el comando az login.

  1. Para configurar kubectl para conectarse a su clúster de Kubernetes, use 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 myAKSCluster
    
  2. Para comprobar la conexión al clúster, use el comando kubectl get para devolver una lista de los nodos del clúster.

    kubectl get nodes
    

    La salida del ejemplo siguiente muestra el nodo único creado en los pasos anteriores. Asegúrese de que el estado del nodo es Listo.

    NAME                                STATUS   ROLES   AGE     VERSION
    aks-nodepool1-31718369-0   Ready    agent   6m44s   v1.15.10
    

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. En Cloud Shell, abra un editor y cree un archivo denominado aks-store-quickstart.yaml.

  2. Pegue el siguiente manifiesto en el editor:

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

  3. 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 siguiente salida de ejemplo muestra las implementaciones y los servicios:

    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
    

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

Eliminación del clúster

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

  1. En Azure Portal, vaya al grupo de recursos del clúster de AKS.

  2. Seleccione Eliminar grupo de recursos.

  3. Escriba el nombre del grupo de recursos que desea eliminar y seleccione Eliminar>Eliminar.

    Nota:

    El clúster de AKS se creó con una identidad administrada asignada por el sistema. Esta identidad se administra mediante la plataforma y no requiere eliminación.

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.