Inicio rápido: Implementación de un clúster de AKS de Azure Linux con OS Guard (versión preliminar) mediante una plantilla de ARM

Empiece a trabajar con el host de contenedor de Linux en Azure mediante una plantilla de Azure Resource Manager (ARM) para implementar un clúster de host de contenedor de Linux en Azure. Después de instalar los requisitos previos, instalará la extensión de la CLI de Azure aks-preview, registrará la marca de característica AzureLinuxOSGuardPreview, creará un par de claves SSH, revisará la plantilla, implementará la plantilla y la validará y, a continuación, implementará una aplicación.

Una plantilla de Azure Resource Manager es un archivo de notación de objetos JavaScript (JSON) que define tanto la infraestructura como la configuración de un proyecto. La plantilla usa sintaxis declarativa. Describes tu implementación deseada sin escribir la secuencia de comandos de programación para crearla.

Consideraciones y limitaciones

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 OS Guard en AKS en fase de vista previa.
NodeImage y None son los únicos canales de actualización del sistema operativo compatibles 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 Sandboxing de pods.
No se admiten máquinas virtuales confidenciales (CVM).
No se admiten máquinas virtuales (VM) gen 1.

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 prefieres ejecutar comandos de referencia CLI localmente, instala la CLI de Azure. Si estás utilizando Windows o macOS, considera ejecutar Azure CLI en un contenedor Docker. Para obtener más información, consulte Cómo ejecutar el Azure CLI en un contenedor de Docker.
- Si estás utilizando una instalación local, inicia sesión en Azure CLI utilizando 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 Azure CLI.
- En caso de que se le solicite, instale las extensiones de la CLI de Azure la primera vez que la use. Para más información sobre las extensiones, consulte Uso de extensiones con la CLI de Azure.
- Ejecute az version para ver la versión y las bibliotecas dependientes que están instaladas. Para actualizar a la versión más reciente, ejecute az upgrade.
Si aún no tiene kubectl instalado, instálelo a través de la CLI de Azure mediante az aks install-cli o siga las instrucciones ascendentes.
Para crear un clúster de AKS con una plantilla de administración de recursos, proporcione una clave pública SSH. Si necesita este recurso, consulte la sección siguiente; en caso contrario, vaya a la sección Revisión de la plantilla.
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).
Para implementar un archivo de Bicep o una plantilla de ARM, necesitas acceso de escritura en los recursos que estás implementando y acceso para realizar todas las operaciones en el 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.

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

Importante

Las características en versión preliminar de AKS están disponibles a elección del usuario y en régimen de autoservicio. Las versiones preliminares se proporcionan "tal cual" y "como están disponibles", y están excluidas de los Acuerdos de nivel de servicio y garantía limitada. Las versiones preliminares de AKS cuentan con soporte parcial por parte del servicio al cliente en la medida de lo posible. Por lo tanto, estas características no están diseñadas para su uso en producción. Para más información, consulte los siguientes artículos de soporte:

Ejecute el siguiente comando para instalar la extensión de versión preliminar de AKS:

az extension add --name aks-preview

Ejecute el siguiente comando para actualizar a la versión más reciente de la extensión publicada:

az extension update --name aks-preview

Registra la característica de bandera AzureLinuxOSGuardPreview

Registre la AzureLinuxOSGuardPreview marca de característica mediante el comando [az feature register][az-feature-register], como se muestra en el ejemplo siguiente:

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

Tarda unos minutos en que el estado muestre Registrado. Compruebe el estado del registro mediante el comando [az feature show][az-feature-show] :

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

Cuando el estado refleje Registrado, actualice el registro del proveedor de recursos Microsoft.ContainerService mediante el comando [az provider register][az-provider-register] :

az provider register --namespace "Microsoft.ContainerService"

Creación de un par de claves SSH

Para acceder a los nodos de AKS, se conectará mediante un par de claves SSH (pública y privada), que se genera mediante el comando ssh-keygen. De forma predeterminada, estos archivos se crean en el directorio ~/.ssh. La ejecución del comando ssh-keygen sobrescribe cualquier par de claves SSH con el mismo nombre que ya exista en la ubicación especificada.

Vaya a https://shell.azure.com para abrir Cloud Shell en el explorador.
Ejecute el comando ssh-keygen. En el ejemplo siguiente se crea un par de claves SSH con cifrado RSA y una longitud en bits de 4096:
```
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 de la plantilla

En la siguiente implementación se usa una plantilla de ARM que se encuentra en Plantillas de inicio rápido de Azure.

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.1",
    "parameters": {
        "clusterName": {
            "defaultValue": "osguardakscluster",
            "type": "String",
            "metadata": {
                "description": "The name of the Managed Cluster resource."
            }
        },
        "location": {
            "defaultValue": "[resourceGroup().location]",
            "type": "String",
            "metadata": {
                "description": "The location of the Managed Cluster resource."
            }
        },
        "dnsPrefix": {
            "type": "String",
            "metadata": {
                "description": "Optional DNS prefix to use with hosted Kubernetes API server FQDN."
            }
        },
        "agentCount": {
            "defaultValue": 3,
            "minValue": 1,
            "maxValue": 50,
            "type": "Int",
            "metadata": {
                "description": "The number of nodes for the cluster."
            }
        },
        "agentVMSize": {
            "defaultValue": "Standard_DS2_v2",
            "type": "String",
            "metadata": {
                "description": "The size of the Virtual Machine."
            }
        },
        "osSKU": {
            "defaultValue": "AzureLinuxOSGuard",
            "allowedValues": [
                "AzureLinuxOSGuard",
                "AzureLinux3OSGuard"
            ],
            "type": "String",
            "metadata": {
                "description": "The Linux SKU to use."
            }
        }
    },
    "resources": [
        {
            "type": "Microsoft.ContainerService/managedClusters",
            "apiVersion": "2025-05-01",
            "name": "[parameters('clusterName')]",
            "location": "[parameters('location')]",
            "identity": {
                "type": "SystemAssigned"
            },
            "properties": {
                "dnsPrefix": "[parameters('dnsPrefix')]",
                "agentPoolProfiles": [
                    {
                        "name": "agentpool",
                        "mode": "System",
                        "count": "[parameters('agentCount')]",
                        "vmSize": "[parameters('agentVMSize')]",
                        "osType": "Linux",
                        "osSKU": "[parameters('osSKU')]",
                        "osDiskType": "Managed",
                        "enableFIPS": true,
                        "securityProfile": {
                            "enableSecureBoot": true,
                            "enableVTPM": true
                        },
                    }
                ]
            }
        }
    ],
    "outputs": {
        "controlPlaneFQDN": {
            "type": "String",
            "value": "[reference(parameters('clusterName')).fqdn]"
        }
    }
}

Para agregar Azure Linux con OS Guard a una plantilla de ARM existente, debe agregar:

"osSKU": "AzureLinuxOSGuard"
"mode": "System" a agentPoolProfiles
"osDiskType": "Managed" a agentPoolProfiles
"enableFIPS": true a agentPoolProfiles
"securityProfile": {enableSecureBoot: true enableVTPM: true} a agentPoolProfiles
Establezca "apiVersion" a 2025-05-01 o más reciente ("apiVersion": "2025-05-01").

Implementación de la plantilla

Seleccione el botón siguiente para iniciar sesión en Azure y abrir una plantilla.
Seleccione o escriba los siguientes valores.

Para este inicio rápido, deje los valores predeterminados de Tamaño del disco del SO GB, Número de agentes, Tamaño de VM del agente, Tipo de SO y Versión de Kubernetes. Proporcione sus propios valores para los siguientes parámetros de plantilla:
- Suscripción: Seleccione una suscripción de Azure.
- Grupo de recursos: Seleccione Crear nuevo. Escriba un nombre único para el grupo de recursos, como testAzureLinuxOSGuardResourceGroup y elija Aceptar.
- Ubicación: seleccione una ubicación, como Este de EE. UU.
- Nombre del clúster: escriba un nombre único para el clúster de AKS, como testAzureLinuxOSGuardCluster.
- Prefijo DNS: escriba un prefijo DNS único para el clúster, como myAzureLinuxOSGuardCluster.
- 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).
Seleccione Revisar + crear.

Se tarda unos minutos en crear el clúster de Azure Linux con OS Guard. Espere a que el clúster se implemente correctamente para pasar al siguiente paso.

Validación de la implementación

Conectarse al clúster

Para administrar un clúster de Kubernetes, use kubectl, el cliente de línea de comandos de Kubernetes.

Instale kubectl localmente mediante el comando az aks install-cli:
```
az aks install-cli
```
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 testAzureLinuxOSGuardResourceGroup --name testAzureLinuxCluster
```

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

El siguiente ejemplo de salida muestra los tres nodos creados en los pasos anteriores. Asegúrese de que el estado del nodo es Listo:

NAME                       STATUS   ROLES   AGE     VERSION
aks-agentpool-41324942-0   Ready    agent   6m44s   v1.12.6
aks-agentpool-41324942-1   Ready    agent   6m46s   v1.12.6
aks-agentpool-41324942-2   Ready    agent   6m45s   v1.12.6

Implementación de la aplicación

Un archivo de manifiesto de Kubernetes define el estado deseado del clúster, por ejemplo, qué imágenes de contenedor se van a ejecutar.

En este inicio rápido usará un manifiesto a fin de crear todos los objetos necesarios para ejecutar la aplicación Azure Vote. Este manifiesto incluye dos implementaciones de Kubernetes:

Las aplicaciones de Python de ejemplo de Azure Vote.
Una instancia de Redis.

También se crean dos servicios de Kubernetes:

Un servicio interno para la instancia de Redis.
Un servicio externo para acceder a la aplicación Azure Vote desde Internet.

Cree un archivo llamado azure-vote.yaml.
- Si usa Azure Cloud Shell, este archivo se puede crear mediante code, vi o nano como si trabajara en un sistema físico o virtual:

Copie la siguiente definición de código YAML:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: azure-vote-back
spec:
  replicas: 1
  selector:
    matchLabels:
      app: azure-vote-back
  template:
    metadata:
      labels:
        app: azure-vote-back
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
      - name: azure-vote-back
        image: mcr.microsoft.com/oss/bitnami/redis:6.0.8
        env:
        - name: ALLOW_EMPTY_PASSWORD
          value: "yes"
        resources:
          requests:
            cpu: 100m
            memory: 128Mi
          limits:
            cpu: 250m
            memory: 256Mi
        ports:
        - containerPort: 6379
          name: redis
---
apiVersion: v1
kind: Service
metadata:
  name: azure-vote-back
spec:
  ports:
  - port: 6379
  selector:
    app: azure-vote-back
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: azure-vote-front
spec:
  replicas: 1
  selector:
    matchLabels:
      app: azure-vote-front
  template:
    metadata:
      labels:
        app: azure-vote-front
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
      - name: azure-vote-front
        image: mcr.microsoft.com/azuredocs/azure-vote-front:v1
        resources:
          requests:
            cpu: 100m
            memory: 128Mi
          limits:
            cpu: 250m
            memory: 256Mi
        ports:
        - containerPort: 80
        env:
        - name: REDIS
          value: "azure-vote-back"
---
apiVersion: v1
kind: Service
metadata:
  name: azure-vote-front
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: azure-vote-front

Para obtener un desglose de los archivos de manifiesto de YAML, consulte Implementaciones y manifiestos de YAML.

Implemente la aplicación mediante el comando kubectl apply y especifique el nombre del manifiesto de YAML:
```
kubectl apply -f azure-vote.yaml
```
El ejemplo siguiente es un ejemplo de la salida que muestra las implementaciones y servicios creados exitosamente.
```
deployment "azure-vote-back" created
service "azure-vote-back" created
deployment "azure-vote-front" created
service "azure-vote-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.

Para supervisar el progreso, utilice el comando kubectl get service con el argumento --watch.

kubectl get service azure-vote-front --watch

La salida de EXTERNAL-IP del servicio azure-vote-front aparecerá inicialmente como pendiente.

NAME               TYPE           CLUSTER-IP   EXTERNAL-IP   PORT(S)        AGE
azure-vote-front   LoadBalancer   10.0.37.27   <pending>     80:30572/TCP   6s

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:

azure-vote-front   LoadBalancer   10.0.37.27   52.179.23.131   80:30572/TCP   2m

Para ver la aplicación Azure Vote en acción, abra un explorador web en la dirección IP externa del servicio.

Captura de pantalla de cómo acceder a la aplicación de ejemplo de Azure Vote.

Eliminación del clúster

Si no va a continuar con los siguientes tutoriales, para evitar los cargos de Azure, elimine los recursos innecesarios. Use el comando az group delete para eliminar el grupo de recursos y todos los recursos relacionados.

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

Pasos siguientes

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 y recorrer un ejemplo completo de implementación y administración de clústeres, continúe con el tutorial azure Linux con OS Guard.

Tutorial de Azure Linux OS Guard

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2025-11-05