Inicio rápido: Implementación de un host de contenedor de Linux en Azure para un clúster de AKS mediante Azure PowerShell

Comience a trabajar con el host de contenedor de Linux en Azure mediante Azure PowerShell para implementar un host de contenedor de Linux en Azure para un clúster de AKS. Después de instalar los requisitos previos, creará un grupo de recursos, creará un clúster de AKS, se conectará al clúster y ejecutará una aplicación de ejemplo con varios contenedores en el clúster.

Importante

A partir del 30 de noviembre de 2025, Azure Kubernetes Service (AKS) ya no admite ni proporciona actualizaciones de seguridad para Azure Linux 2.0. La imagen de nodo de Linux 2.0 de Azure está congelada en la versión 202512.06.0. A partir del 31 de marzo de 2026, se quitarán las imágenes de nodo y no podrá escalar los grupos de nodos. Migre a una versión compatible de Azure Linux mediante la actualización de los grupos de nodos a una versión de Kubernetes compatible o la migración a osSku AzureLinux3. Para más información, consulte Retirada: grupos de nodos de Azure Linux 2.0 en AKS.

Requisitos previos

Si no tiene una cuenta de Azure, cree una cuenta gratuita antes de comenzar.
Use el entorno PowerShell en Azure Cloud Shell. Para obtener más información, consulte Inicio rápido de Azure Cloud Shell.
Si va a ejecutar PowerShell de forma local, instale el módulo Az PowerShell y conéctese a su cuenta de Azure con el cmdlet Connect-AzAccount. Para más información sobre cómo instalar el módulo Az PowerShell, consulte Instalación de Azure PowerShell.
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).

Crear un grupo de recursos

Un grupo de recursos de Azure es un grupo lógico en el que se implementan y administran recursos de Azure. Cuando se crea un grupo de recursos, necesita especificar una ubicación. Esta ubicación es la ubicación de almacenamiento de los metadatos del grupo de recursos y donde se ejecutan los recursos en Azure si no se especifica otra región durante la creación de recursos.

En el ejemplo siguiente, se crea un grupo de recursos denominado testAzureLinuxResourceGroup en la región eastus.

Cree un grupo de recursos mediante el cmdlet New-AzResourceGroup.

New-AzResourceGroup -Name testAzureLinuxResourceGroup -Location eastus

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

ResourceGroupName : testAzureLinuxResourceGroup
Location          : eastus
ProvisioningState : Succeeded
Tags              :
ResourceId        : /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/testAzureLinuxResourceGroup

Nota:

En el ejemplo anterior se usa eastus, pero los clústeres de host de contenedor de Linux en Azure están disponibles en todas las regiones.

Creación de un clúster de host de contenedor de Linux en Azure

En el ejemplo siguiente se crea un clúster denominado testAzureLinuxCluster con un nodo.

Cree un clúster de AKS mediante el cmdlet New-AzAksCluster con la marca -NodeOsSKU establecida en AzureLinux.
```
New-AzAksCluster -ResourceGroupName testAzureLinuxResourceGroup -Name testAzureLinuxCluster -NodeOsSKU AzureLinux
```
Transcurridos unos minutos, el comando se completa y devuelve información en formato JSON sobre el clúster.

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.

Para instalar kubectl localmente, use el cmdlet Install-AzAksCliTool.
```
Install-AzAksCliTool
```
Para configurar kubectl para conectarse al clúster de Kubernetes, use el cmdlet Import-AzAksCredential. Con este comando se descargan las credenciales y se configura la CLI de Kubernetes para usarlas.
```
Import-AzAksCredential -ResourceGroupName testAzureLinuxResourceGroup -Name testAzureLinuxCluster
```
Compruebe la conexión al clúster mediante el comando kubectl get. Este comando devuelve una lista de los pods del clúster.
```
kubectl get pods --all-namespaces
```

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 de un clúster, como las imágenes de contenedor que 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 Cosmos DB o Azure Service Bus.

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

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.

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.

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
```
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
```
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 los siguientes tutoriales, quite los recursos creados para evitar incurrir en cargos de Azure.

Elimine el grupo de recursos y todos los recursos relacionados usando el cmdlet RemoveAzResourceGroup.
```
Remove-AzResourceGroup -Name testAzureLinuxResourceGroup
```

Pasos siguientes

En este inicio rápido, ha implementado un clúster de AKS de host de contenedor de Linux en Azure. Para más información sobre el host de contenedor de Linux en Azure y recorrer un ejemplo completo de implementación y administración de clústeres, continúe con el tutorial sobre el host de contenedor de Linux en Azure.

Tutorial sobre el host de contenedor de Linux en Azure

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2025-09-11