Inicio rápido: Implementación de un clúster de Azure Kubernetes Service (AKS) mediante una plantilla de ARM
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 mediante una plantilla de Azure Resource Manager.
- Ejecute una aplicación de varios contenedores de ejemplo con un grupo de microservicios y front-end web simulando un escenario comercial.
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. Se describe la implementación deseada sin escribir la secuencia de comandos de programación para crear la implementación.
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 este artículo 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).
Para implementar una plantilla de ARM, se necesita acceso de escritura en los recursos que se implementan y acceso a todas las operaciones del tipo de recurso
Microsoft.Resources/deployments. Por ejemplo, para implementar una máquina virtual, necesita los permisosMicrosoft.Compute/virtualMachines/writeyMicrosoft.Resources/deployments/*. Para obtener una lista de roles y permisos, consulte Roles integrados de Azure.
Después de implementar el clúster desde la plantilla, puede usar la CLI de Azure o Azure PowerShell para conectarse al clúster e implementar la aplicación de ejemplo.
Use el entorno de Bash en Azure Cloud Shell. Para más información, consulte Inicio rápido para Bash en Azure Cloud Shell.
Si prefiere ejecutar comandos de referencia de la CLI localmente, instale la CLI de Azure. Si utiliza Windows o macOS, considere la posibilidad de ejecutar la CLI de Azure en un contenedor Docker. Para más información, vea Ejecución de la CLI de Azure en un contenedor de Docker.
Si usa una instalación local, inicie sesión en la 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 ver otras opciones de inicio de sesión, consulte Inicio de sesión con la CLI de Azure.
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 buscar cuál es la versión y las bibliotecas dependientes que están instaladas. Para realizar la actualización a la versión más reciente, ejecute az upgrade.
En este artículo se necesita la CLI de Azure versión 2.0.64 o posterior. Si usa Azure Cloud Shell, ya está instalada allí la versión más reciente.
Creación de un par de claves SSH
Para crear un clúster de AKS con una plantilla de ARM, debe proporcionar una clave pública SSH. Si necesita este recurso, siga los pasos de esta sección. De lo contrario, vaya a la sección Revisar la plantilla.
Para acceder a los nodos de AKS, conéctese mediante un par de claves SSH (público y privado). Para crear 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 az sshkey create o el comando
ssh-keygen.# Create an SSH key pair using Azure CLI az sshkey create --name "mySSHKey" --resource-group "myResourceGroup" # or # Create an SSH key pair using ssh-keygen ssh-keygen -t rsa -b 4096Para implementar la plantilla, debe proporcionar la clave pública del par SSH. Para recuperar la clave pública, llame a az sshkey show:
az sshkey show --name "mySSHKey" --resource-group "myResourceGroup" --query "publicKey"
De forma predeterminada, los archivos de clave SSH se crean en el directorio ~/.ssh. Al ejecutar el comando az sshkey create o ssh-keygen se sobrescribirá cualquier par de claves SSH existente con el mismo nombre.
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
La plantilla usada en este inicio rápido forma parte de las plantillas de inicio rápido de Azure.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"metadata": {
"_generator": {
"name": "bicep",
"version": "0.26.170.59819",
"templateHash": "14823542069333410776"
}
},
"parameters": {
"clusterName": {
"type": "string",
"defaultValue": "aks101cluster",
"metadata": {
"description": "The name of the Managed Cluster resource."
}
},
"location": {
"type": "string",
"defaultValue": "[resourceGroup().location]",
"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."
}
},
"osDiskSizeGB": {
"type": "int",
"defaultValue": 0,
"minValue": 0,
"maxValue": 1023,
"metadata": {
"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."
}
},
"agentCount": {
"type": "int",
"defaultValue": 3,
"minValue": 1,
"maxValue": 50,
"metadata": {
"description": "The number of nodes for the cluster."
}
},
"agentVMSize": {
"type": "string",
"defaultValue": "standard_d2s_v3",
"metadata": {
"description": "The size of the Virtual Machine."
}
},
"linuxAdminUsername": {
"type": "string",
"metadata": {
"description": "User name for the Linux Virtual Machines."
}
},
"sshRSAPublicKey": {
"type": "string",
"metadata": {
"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'"
}
}
},
"resources": [
{
"type": "Microsoft.ContainerService/managedClusters",
"apiVersion": "2024-02-01",
"name": "[parameters('clusterName')]",
"location": "[parameters('location')]",
"identity": {
"type": "SystemAssigned"
},
"properties": {
"dnsPrefix": "[parameters('dnsPrefix')]",
"agentPoolProfiles": [
{
"name": "agentpool",
"osDiskSizeGB": "[parameters('osDiskSizeGB')]",
"count": "[parameters('agentCount')]",
"vmSize": "[parameters('agentVMSize')]",
"osType": "Linux",
"mode": "System"
}
],
"linuxProfile": {
"adminUsername": "[parameters('linuxAdminUsername')]",
"ssh": {
"publicKeys": [
{
"keyData": "[parameters('sshRSAPublicKey')]"
}
]
}
}
}
}
],
"outputs": {
"controlPlaneFQDN": {
"type": "string",
"value": "[reference(resourceId('Microsoft.ContainerService/managedClusters', parameters('clusterName')), '2024-02-01').fqdn]"
}
}
}
El tipo de recurso definido en la plantilla de ARM es Microsoft.ContainerService/managedClusters.
Para más ejemplos de AKS, consulte el sitio de plantillas de inicio rápido de AKS.
Implementación de la plantilla
Seleccione Implementar en Azure para iniciar sesión y abrir una plantilla.
En la página Aspectos básicos, deje los valores predeterminados de Tamaño del disco del SO (GB), Número de agentes, Tamaño de VM del agente y Tipo de SO y configure 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 myResourceGroup, y seleccione 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 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.
- Origen de la clave pública SSH: seleccione Usar clave pública existente.
- Nombre del par de claves: 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>Crear.
El clúster de AKS tarda unos minutos en crearse. Espere a que el clúster se implemente correctamente para pasar al siguiente paso.
Conectarse al clúster
Para administrar un clúster de Kubernetes, use la línea de comandos de Kubernetes, kubectl.
Si usa Azure Cloud Shell, kubectl ya está instalado. Para instalar y ejecutar kubectl localmente, llame al comando az aks install-cli.
Para configurar
kubectlpara 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 myAKSClusterCompruebe la conexión al clúster con el comando kubectl get. Este comando devuelve una lista de los nodos del clúster.
kubectl get nodesLa salida del siguiente ejemplo 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-27442051-vmss000000 Ready agent 10m v1.27.7 aks-agentpool-27442051-vmss000001 Ready agent 10m v1.27.7 aks-agentpool-27442051-vmss000002 Ready agent 11m v1.27.7
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:
- 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.yamly 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: LoadBalancerPara 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.
Implemente la aplicación mediante el comando kubectl apply y especifique el nombre del manifiesto de YAML:
kubectl apply -f aks-store-quickstart.yamlLa 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
Compruebe el estado de los pods implementados con el comando kubectl get pods. Haga que todos los pods tengan el estado
Runningantes de continuar.kubectl get podsCompruebe 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 --watchLa salida de EXTERNAL-IP del servicio
store-frontaparece inicialmente como pending (pendiente):NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE store-front LoadBalancer 10.0.100.10 <pending> 80:30025/TCP 4h4mUna vez que la dirección EXTERNAL-IP cambia de pendiente a una dirección IP pública real, use
CTRL-Cpara detener elkubectlproceso 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 4h5mAbra 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.
Quite el grupo de recursos, el servicio de contenedor y todos los recursos relacionados llamando al comando az group delete.
az group delete --name myResourceGroup --yes --no-wait
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.
Azure Kubernetes Service