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

8 minutos

Para poder automatizar las implementaciones de sitios web, debe implementar manualmente la aplicación eShop existente en Azure Kubernetes Service (AKS). Tú creas los recursos de Azure y despliegas la aplicación en AKS utilizando comandos de la CLI de Azure y scripts de Bash. 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 Acciones de GitHub se implementen 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

Haz un fork del https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative-devops repositorio a tu propia cuenta de GitHub. A continuación, en la nueva bifurcación:

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

GitHub tarda varios minutos en crear y configurar el espacio de código. 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, haga un fork del https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative-devops repositorio en su propia cuenta de GitHub y clónelo localmente. A continuación:

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

Construir 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 selecciona la suscripción incorrecta, use el comando az account set para seleccionar el correcto.
Ejecute el siguiente comando de la CLI de Azure para obtener una lista de regiones de Azure y el nombre asociado a él:
```
az account list-locations -o table
```
Busque una región más cercana a usted 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 a ti, como eastus. 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 el portal de Azure, 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 az acr login --name $ACR_Name se ejecuta, debe activar el 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. También puede que tenga que autenticarse de nuevo 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 crean un clúster de AKS de nodo único, lo conectan al ACR y, a continuación, conectan la máquina local al clúster de AKS. Los comandos 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 una salida 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 una salida 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 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 o Codespaces, 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 de 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 kubectl comando 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 una salida 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 recibe algún error en las implementaciones.

Debería ver una salida 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 una salida 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 devuelve la dirección IP externa de la aplicación web. Mantenga presionada la tecla CTRL 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

Acciones de GitHub pueden publicar imágenes de contenedor en un 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.

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

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

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.

Crea 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 Actions secrets and variables página, seleccione New repository secret.
En la New secret página, en Name, escriba AZURE_CREDENTIALS y, en Secret, escriba la salida JSON que copió del terminal.

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

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

Comentarios

¿Le ha resultado útil esta página?