Implementación manual de una aplicación nativa de nube en Azure Kubernetes Service

8 minutos

Para poder automatizar las implementaciones de sitios web, debe implementar la aplicación eShop existente manualmente en Azure Kubernetes Service (AKS). Con comandos de la CLI de Azure y scripts de Bash, creará los recursos de Azure e implementará la aplicación en AKS. Por último, cree una entidad de servicio de Azure Active Directory (Azure AD) para permitir que se implementen GitHub Actions en AKS y Azure Container Registry.

Los comandos crean los siguientes recursos para implementar una versión actualizada de la aplicación eShop.

Aprovisione una instancia de Azure Container Registry (ACR) y, a continuación, inserte imágenes en el registro.
Aprovisione un clúster de AKS y, a continuación, implemente los contenedores en el clúster.
Pruebe la implementación.
Cree entidades de servicio para permitir que se implementen GitHub Actions en AKS y Azure Container Registry.

Importante

Asegúrese de que ha completado los requisitos previos antes de comenzar.

Abrir el entorno de desarrollo

Puede optar por usar un codespace de GitHub que hospede el ejercicio, o bien hacer el ejercicio localmente en Visual Studio Code.

Configuración de GitHub Codespaces

Bifurque el repositorio de https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative-devops a su cuenta de GitHub. A continuación, en la nueva bifurcación:

Seleccione Código.
Seleccione la pestaña Codespaces.
Seleccione el icono de + para crear el espacio de código.

GitHub tarda unos minutos en crear y configurar el codespace. Cuando se complete el proceso, verá los archivos de código del ejercicio.

Opcional: Configuración de Visual Studio Code

Para usar Visual Studio Code, bifurque el repositorio de https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative-devops en su propia cuenta de GitHub y clónelo localmente. Después:

Instale cualquier requisito del sistema para ejecutar el Contenedor de desarrollo en Visual Studio Code.
Asegúrese de que Docker se está ejecutando.
En una nueva ventana de Visual Studio Code, abra la carpeta del repositorio clonado
Presione Ctrl+Mayús+P para abrir la paleta de comandos.
Buscar: >Dev Containers: Recompilar y volver a abrir en contenedor
Visual Studio Code crea el contenedor de desarrollo localmente.

Compilar contenedores

En el panel del terminal, ejecute este comando de la CLI de dotnet:
```
dotnet publish /p:PublishProfile=DefaultContainer 
```

Creación de recursos de Azure

En el panel del terminal, inicie sesión en Azure con este comando de la CLI de Azure:
```
az login --use-device-code
```
Vea la suscripción de Azure seleccionada.
```
az account show -o table
```
Si se seleccionó una suscripción incorrecta, use el comando az account set para seleccionar la correcta.
Ejecute el siguiente comando de la CLI de Azure para obtener una lista de las regiones de Azure y el nombre asociado a ella:
```
az account list-locations -o table
```
Busque una región más cercana y úsela en el paso siguiente reemplazando [Closest Azure region]
Ejecute estas instrucciones bash:
```
export LOCATION=[Closest Azure region]
export RESOURCE_GROUP=rg-eshop
export CLUSTER_NAME=aks-eshop
export ACR_NAME=acseshop$SRANDOM
```
Los comandos anteriores crean variables de entorno que usará en los siguientes comandos de la CLI de Azure. Debe cambiar la UBICACIÓN a una región de Azure cercana; por ejemplo, Este de EE. UU. Si desea un nombre diferente para el grupo de recursos, el clúster de AKS o ACR, cambie esos valores. Para ver los nuevos repositorios en Azure Portal, asígnese como Administrador de automatización de cumplimiento de aplicaciones en el control de acceso (IAM) del registro de contenedor.
Ejecute estos comandos de la CLI de Azure:
```
az group create --name $RESOURCE_GROUP --location $LOCATION
az acr create --resource-group $RESOURCE_GROUP --name $ACR_NAME --sku Basic
az acr login --name $ACR_NAME
```
Si recibe un error de autenticación cuando se ejecuta az acr login --name $ACR_Name, debe activar Usuario administrador en el Registro de contenedor recién creado en Azure en Configuración: Claves de acceso. Azure le pide que escriba estas credenciales para continuar. Es posible que también tenga que volver a autenticarse con az login --use-device-code.

Estos comandos crean un grupo de recursos para contener los recursos de Azure, un ACR para las imágenes y, a continuación, inician sesión en ACR. Puede tardar unos minutos hasta que vea esta salida:
```
  ...
  },
  "status": null,
  "systemData": {
    "createdAt": "2023-10-19T09:11:51.389157+00:00",
    "createdBy": "",
    "createdByType": "User",
    "lastModifiedAt": "2023-10-19T09:11:51.389157+00:00",
    "lastModifiedBy": "",
    "lastModifiedByType": "User"
  },
  "tags": {},
  "type": "Microsoft.ContainerRegistry/registries",
  "zoneRedundancy": "Disabled"
}
Login Succeeded
```

Para etiquetar las imágenes e insertarlas en el ACR que creó, ejecute estos comandos:

docker tag store $ACR_NAME.azurecr.io/storeimage:v1
docker tag products $ACR_NAME.azurecr.io/productservice:v1

docker push $ACR_NAME.azurecr.io/storeimage:v1
docker push $ACR_NAME.azurecr.io/productservice:v1

Puede comprobar que la inserción de las imágenes se completa correctamente con este comando:

az acr repository list --name $ACR_NAME --output table

Cree su AKS y conéctelo al ACR con estos comandos:
```
az aks create --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME --node-count 1 --generate-ssh-keys --node-vm-size Standard_B2s --network-plugin azure --attach-acr $ACR_NAME

az aks get-credentials --name $CLUSTER_NAME --resource-group $RESOURCE_GROUP
```
Los comandos anteriores crean un clúster de AKS de un solo nodo, lo conectan al ACR y, a continuación, conectan la máquina local al clúster de AKS. Los comandos anteriores pueden tardar unos minutos en completarse.

Compruebe que el nuevo AKS puede extraer imágenes de ACR con este comando:

az aks check-acr --acr $ACR_NAME.azurecr.io --name $CLUSTER_NAME --resource-group $RESOURCE_GROUP

Debería ver un resultado similar a los mensajes siguientes:

[2023-10-19T13:33:09Z] Loading azure.json file from /etc/kubernetes/azure.json
[2023-10-19T13:33:09Z] Checking managed identity...
[2023-10-19T13:33:09Z] Cluster cloud name: AzurePublicCloud
[2023-10-19T13:33:09Z] Kubelet managed identity client ID: 00001111-aaaa-2222-bbbb-3333cccc4444
[2023-10-19T13:33:09Z] Validating managed identity existance: SUCCEEDED
[2023-10-19T13:33:09Z] Validating image pull permission: SUCCEEDED
[2023-10-19T13:33:09Z] 
Your cluster can pull images from acseshop1251599299.azurecr.io!

Ahora puede ejecutar comandos kubectl en el nuevo clúster de AKS. Copie la dirección URL de ACR completa a partir de la salida; por ejemplo, acseshop1251599299 se encuentra encima de la dirección URL.

Compruebe el estado del clúster de AKS:

kubectl get nodes -A

Debería ver un resultado similar a los mensajes siguientes:

NAME                                STATUS   ROLES   AGE     VERSION
aks-nodepool1-37200563-vmss000000   Ready    agent   3h44m   v1.26.6

Configuración del manifiesto de implementación de Kubernetes

Ahora que las imágenes de eShop están en el ACR, puede actualizar el manifiesto de implementación de AKS para usar estas nuevas imágenes.

En Visual Studio Code, en el panel EXPLORADOR, seleccione el archivo deployment.yml en la raíz del proyecto.
Reemplace en la línea 17:
```
- image: [replace with your ACR name].azurecr.io/storeimage:v1
```
Pegue el nombre de ACR copiado del paso anterior: la línea debe tener un aspecto similar al siguiente código yaml:
```
- image: acseshop1251599299.azurecr.io/storeimage:v1
```

Repita estos pasos para la línea 65:

- image: [replace with your ACR name].azurecr.io/productservice:v1

Guarde el archivo con CTRL+S.

En el panel del terminal, implemente un controlador de entrada NGINX con el siguiente comando de Kubernetes:

kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.9.3/deploy/static/provider/cloud/deploy.yaml

El comando anterior kubectl agrega servicios y componentes para permitir la entrada en el clúster de AKS. Compruebe que la entrada está lista para ejecutarse mediante el siguiente comando de Kubernetes:

kubectl get services --namespace ingress-nginx

Debería ver un resultado similar a los mensajes siguientes:

NAME                                 TYPE           CLUSTER-IP     EXTERNAL-IP    PORT(S)                      AGE
ingress-nginx-controller             LoadBalancer   10.0.135.51    20.26.154.64   80:32115/TCP,443:32254/TCP   58s
ingress-nginx-controller-admission   ClusterIP      10.0.137.137   <none>         443/TCP                      58s

Implemente la aplicación eShop con este comando:
```
kubectl apply -f deployment.yml
```
El comando kubectl apply implementa la aplicación eShop, una aplicación web Blazor de front-end y un servicio de producto de la API de REST de back-end, y una regla de entrada para enrutar el tráfico a los servicios correctos al clúster de AKS. Vuelva a ejecutar este comando si se produce algún error en las implementaciones.

Debería ver un resultado similar a los mensajes siguientes:
```
deployment.apps/storeimage created
service/eshop-website created
deployment.apps/productservice created
service/eshop-backend created
ingress.networking.k8s.io/eshop-ingress created
```

Compruebe que los dos microservicios se implementan con este comando:

kubectl get pods -A

Debería ver un resultado similar a los mensajes siguientes:

NAMESPACE       NAME                                        READY   STATUS      RESTARTS   AGE
default         productservice-7569b8c64-vfbfz              1/1     Running     0          3m56s
default         storeimage-6c7c999d7c-zsnxd                 1/1     Running     0          3m56s
ingress-nginx   ingress-nginx-admission-create-szb8l        0/1     Completed   0          4m4s
ingress-nginx   ingress-nginx-admission-patch-czdbv         0/1     Completed   0          4m4s
ingress-nginx   ingress-nginx-controller-58bf5bf7dc-nwtsr   1/1     Running     0          4m4s

Vea el eShop implementado con este comando:
```
echo "http://$(kubectl get services --namespace ingress-nginx ingress-nginx-controller --output jsonpath='{.status.loadBalancer.ingress[0].ip}')"
```
El comando anterior devuelve la dirección IP externa de la aplicación web. Mantenga presionada la tecla Control y haga clic en el vínculo para abrir la aplicación en una nueva pestaña.

Crear una entidad de servicio para la implementación desde GitHub

GitHub Actions puede publicar imágenes de contenedor en una instancia de Azure Container Registry. Por lo tanto, el ejecutor de GitHub debe tener permisos para conectarse a Azure. En los pasos siguientes se crea una entidad de servicio de Azure AD para que actúe como la identidad de Acciones de GitHub dentro de Azure.

Ejecute el siguiente comando en el terminal para guardar el identificador de suscripción en una variable de entorno:
```
export SUBS=$(az account show --query 'id' --output tsv)
```

Ejecute el siguiente comando para crear una entidad de servicio de Azure AD para permitir el acceso desde GitHub:

az ad sp create-for-rbac --name "eShop" --role contributor --scopes /subscriptions/$SUBS/resourceGroups/$RESOURCE_GROUP --json-auth

Aparece una variación del resultado siguiente:

Creating 'Contributor' role assignment under scope '/subscriptions/ffffffff-aaaa-bbbb-6666-777777777777'

The output includes credentials that you must protect. Be sure that you do not include these credentials in your code or check the credentials into your source control. For more information, see https://aka.ms/azadsp-cli
 {
  "clientId": "00001111-aaaa-2222-bbbb-3333cccc4444",
  "clientSecret": "abc1A~abc123ABC123abc123ABC123abc123ABC1",
  "subscriptionId": "00000000-0000-0000-0000-000000000000",
  "tenantId": "00000000-0000-0000-0000-000000000000",
  "activeDirectoryEndpointUrl": "https://login.microsoftonline.com",
  "resourceManagerEndpointUrl": "https://management.azure.com/",
  "activeDirectoryGraphResourceId": "https://graph.windows.net/",
  "sqlManagementEndpointUrl": "https://management.core.windows.net:8443/",
  "galleryEndpointUrl": "https://gallery.azure.com/",
  "managementEndpointUrl": "https://management.core.windows.net/"
}

Copie los corchetes y la salida JSON que se van a usar en el paso siguiente.

Creación de los secretos de GitHub

El ejecutor de Acciones de GitHub usa credenciales para interactuar con Container Registry y AKS. La entidad de servicio y las credenciales del registro de contenedor son información confidencial. Es mejor almacenar información confidencial como secretos cifrados en una ubicación segura. GitHub proporciona una ubicación integrada para almacenar secretos y otras variables.

Complete los pasos siguientes para almacenar de forma segura la información confidencial como variables de entorno en el repositorio. Los administradores del repositorio deben administrar los secretos a los que puede acceder el ejecutor de Acciones de GitHub.

En el repositorio de GitHub bifurcado, vaya a Settings>Secrets and variables>Actions.
En la página Actions secrets and variables, seleccione New repository secret.
En la página New secret, en Name escriba AZURE_CREDENTIALS y, en Secret, escriba la salida JSON que copió del terminal.

La configuración debería ser similar a la captura de pantalla siguiente:
Seleccione Add secret.

Usará este secreto de GitHub en la siguiente sección para crear una acción de GitHub para compilar la imagen de contenedor.

Implementación manual de una aplicación nativa de nube en Azure Kubernetes Service

Abrir el entorno de desarrollo

Configuración de GitHub Codespaces

Opcional: Configuración de Visual Studio Code

Compilar contenedores

Creación de recursos de Azure

Configuración del manifiesto de implementación de Kubernetes

Crear una entidad de servicio para la implementación desde GitHub

Creación de los secretos de GitHub

Comentarios