Inicio rápido: Implementación de un clúster de Azure Linux con OS Guard (versión preliminar) Azure Kubernetes Service (AKS) mediante el CLI de Azure

En este inicio rápido, aprenderá a:

Prerrequisitos

• Si no tiene una cuenta de Azure, cree una cuenta gratuita antes de comenzar.

• Use el entorno de Bash en Azure Cloud Shell. Para más información, vea Inicio rápido de Azure Cloud Shell: Bash.

  

• Si prefiere ejecutar comandos de referencia de la CLI localmente, instale el CLI de Azure. Si estás utilizando Windows o macOS, considera ejecutar CLI de Azure en un contenedor Docker. Para obtener más información, consulte Cómo ejecutar el CLI de Azure en un contenedor de Docker.

  • Si usa una instalación local, inicie sesión en el CLI de Azure mediante el comando az login. Siga los pasos que se muestran en el terminal para completar el proceso de autenticación. Para otras opciones de inicio de sesión, consulta Iniciar sesión con CLI de Azure.
  • Cuando se le solicite, instale la extensión CLI de Azure en el primer uso. Para más información sobre las extensiones, consulte Uso de extensiones con la CLI de Azure.
  • Ejecute az version para buscar cuál es la versión y las bibliotecas dependientes que están instaladas. Para actualizar a la versión más reciente, ejecute az upgrade.

Azure Linux con consideraciones y limitaciones de OS Guard

Antes de empezar, revise las siguientes consideraciones y limitaciones para Azure Linux con OS Guard (versión preliminar):

• La versión 1.32.0 o posterior de Kubernetes es necesaria para Azure Linux con OS Guard.
• Todas las imágenes de Azure Linux con OS Guard tienen habilitado el Estándar federal de proceso de información (FIPS) y el Inicio seguro.
• Las plantillas de la CLI de Azure y ARM son los únicos métodos de implementación admitidos para Azure Linux con OS Guard en AKS en versión preliminar. PowerShell y Terraform no están admitidos.
• Las imágenes de Arm64 no se admiten en Azure Linux con protección de sistema operativo en AKS en versión preliminar.
• NodeImage y None son los únicos canales de actualización admitidos operating system (OS) para Azure Linux con OS Guard en AKS. Unmanaged y SecurityPatch son incompatibles con Azure Linux con OS Guard debido al directorio /usr inmutable.
• No se admite el streaming de artefactos.
• No se admite el espacio aislado de pods.
• No se admiten máquinas virtuales confidenciales (CVM).
• No se admiten máquinas virtuales (VM) gen 1.

Instalación de la extensión aks-preview CLI de Azure

Instale la extensión aks-preview mediante el comando az extension add.

az extension add --name aks-preview

Actualice la aks-preview extensión a la versión más reciente mediante el az extension update comando .

az extension update --name aks-preview

Registro de la marca de característica AzureLinuxOSGuardPreview

1. Registre la marca de características de AzureLinuxOSGuardPreview mediante el comando az feature register.

   az feature register --namespace "Microsoft.ContainerService" --name "AzureLinuxOSGuardPreview"
   

   Tarda unos minutos en que el estado muestre Registrado.

2. Comprobar el estado del registro mediante el comando az feature show.

   az feature show --namespace "Microsoft.ContainerService" --name "AzureLinuxOSGuardPreview"
   

3. Cuando aparezca el estado Registrado, actualice el registro del proveedor de recursos Microsoft.ContainerService mediante el comando az provider register.

   az provider register --namespace "Microsoft.ContainerService"
   

Establecimiento de variables de entorno

Establezca las siguientes variables de entorno para crear nombres de recursos únicos para cada implementación. Reemplace <your-resource-group-name>, <your-region> y <your-cluster-name> con sus propios valores. Opcionalmente, puede usar el openssl rand -hex 3 comando para generar una cadena aleatoria para anexar al grupo de recursos y los nombres de clúster (por ejemplo, export RESOURCE_GROUP="myResourceGroup$RANDOM_ID").

# Create random string
export RANDOM_ID="$(openssl rand -hex 3)"

# Set environment variables
export RESOURCE_GROUP="<your-resource-group-name>"
export REGION="<your-region>"
export CLUSTER_NAME="<your-cluster-name>"

Creación de un grupo de recursos

Un grupo de recursos de Azure es un grupo lógico en el que se implementan y administran los recursos de Azure. Al crear un grupo de recursos en Azure, es necesario especificar una ubicación. Esta ubicación es la ubicación de almacenamiento de los metadatos del grupo de recursos y dónde se ejecutan los recursos en Azure si no especifica otra región al crear un recurso.

Cree un grupo de recursos con el comando az group create.

az group create --name $RESOURCE_GROUP --location $REGION

Ejemplo de resultado:

{
  "id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/$RESOURCE_GROUPxxxxxx",
  "location": "$REGION",
  "managedBy": null,
  "name": "$RESOURCE_GROUPxxxxxx",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null,
  "type": "Microsoft.Resources/resourceGroups"
}

Creación de un clúster de Azure Linux con OS Guard

Cree un clúster de AKS mediante el az aks create comando con el --os-sku parámetro para aprovisionar el clúster de AKS con una imagen de Azure Linux con OS Guard.

az aks create --name $CLUSTER_NAME --resource-group $RESOURCE_GROUP --os-sku AzureLinuxOSGuard --node-osdisk-type Managed --enable-fips-image --enable-secure-boot --enable-vtpm 

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 el cliente de línea de comandos de Kubernetes, kubectl. kubectl ya está instalado si usa Azure Cloud Shell. Para instalar kubectl localmente, use el comando az aks install-cli.

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 $RESOURCE_GROUP --name $CLUSTER_NAME
   

2. Compruebe la conexión al clúster con el comando kubectl get. Este comando devuelve una lista de los nodos del clúster.

   kubectl get nodes
   

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:

• Tienda virtual: aplicación web en línea 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 utilizada para gestionar pedidos.

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

   apiVersion: apps/v1
   kind: StatefulSet
   metadata:
     name: rabbitmq
   spec:
     serviceName: rabbitmq
     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
           startupProbe:
             httpGet:
               path: /health
               port: 3000
             failureThreshold: 5
             initialDelaySeconds: 20
             periodSeconds: 10
           readinessProbe:
             httpGet:
               path: /health
               port: 3000
             failureThreshold: 3
             initialDelaySeconds: 3
             periodSeconds: 5
           livenessProbe:
             httpGet:
               path: /health
               port: 3000
             failureThreshold: 5
             initialDelaySeconds: 3
             periodSeconds: 3
         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
           env: 
           - name: AI_SERVICE_URL
             value: "http://ai-service:5001/"
           resources:
             requests:
               cpu: 1m
               memory: 1Mi
             limits:
               cpu: 2m
               memory: 20Mi
           readinessProbe:
             httpGet:
               path: /health
               port: 3002
             failureThreshold: 3
             initialDelaySeconds: 3
             periodSeconds: 5
           livenessProbe:
             httpGet:
               path: /health
               port: 3002
             failureThreshold: 5
             initialDelaySeconds: 3
             periodSeconds: 3
   ---
   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
           startupProbe:
             httpGet:
               path: /health
               port: 8080
             failureThreshold: 3
             initialDelaySeconds: 5
             periodSeconds: 5
           readinessProbe:
             httpGet:
               path: /health
               port: 8080
             failureThreshold: 3
             initialDelaySeconds: 3
             periodSeconds: 3
           livenessProbe:
             httpGet:
               path: /health
               port: 8080
             failureThreshold: 5
             initialDelaySeconds: 3
             periodSeconds: 3
   ---
   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.

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
   

Prueba de la aplicación

Puede validar que la aplicación se está ejecutando visitando la dirección IP pública o la dirección URL de la aplicación.

Obtenga la dirección URL de la aplicación mediante los siguientes comandos:

runtime="5 minutes"
endtime=$(date -ud "$runtime" +%s)
while [[ $(date -u +%s) -le $endtime ]]
do
   STATUS=$(kubectl get pods -l app=store-front -o 'jsonpath={..status.conditions[?(@.type=="Ready")].status}')
   echo $STATUS
   if [ "$STATUS" == 'True' ]
   then
      export IP_ADDRESS=$(kubectl get service store-front --output 'jsonpath={..status.loadBalancer.ingress[0].ip}')
      echo "Service IP Address: $IP_ADDRESS"
      break
   else
      sleep 10
   fi
done

curl $IP_ADDRESS

Resultados:

<!doctype html>
<html lang="">
   <head>
      <meta charset="utf-8">
      <meta http-equiv="X-UA-Compatible" content="IE=edge">
      <meta name="viewport" content="width=device-width,initial-scale=1">
      <link rel="icon" href="/favicon.ico">
      <title>store-front</title>
      <script defer="defer" src="/js/chunk-vendors.df69ae47.js"></script>
      <script defer="defer" src="/js/app.7e8cfbb2.js"></script>
      <link href="/css/app.a5dc49f6.css" rel="stylesheet">
   </head>
   <body>
      <div id="app"></div>
   </body>
</html>

echo "You can now visit your web server at $IP_ADDRESS"

Eliminación del clúster

Si ya no los necesita, puede limpiar recursos innecesarios para evitar cargos de Azure.

Elimine el grupo de recursos Azure y todos los recursos relacionados mediante el comando az group delete.

az group delete --name $RESOURCE_GROUP --yes --no-wait

Contenido relacionado

En este inicio rápido, ha implementado una instancia de Azure Linux con un clúster de OS Guard. Para más información sobre Azure Linux con OS Guard, consulte los siguientes recursos:

• serie de tutoriales de Azure Linux OS Guard: Parte 1
• Información general de Azure Linux OS Guard para AKS