Implantar manualmente seu aplicativo nativo de nuvem no Serviço de Kubernetes do Azure

8 minutos

Antes de automatizar as implantações do site, você precisa implantar o aplicativo eShop existente manualmente no AKS (Serviço de Kubernetes do Azure). Você cria os recursos do Azure e implanta o aplicativo no AKS usando comandos da CLI do Azure e scripts bash. Finalmente, você criará uma entidade de serviço no Azure AD (Azure Active Directory) para permitir que o GitHub Actions seja implantado no AKS e no Registro de Contêiner do Azure.

Os comandos criam os seguintes recursos para implantar uma versão atualizada do aplicativo eShop.

Provisione um Registro de Contêiner do Azure (ACR) e envie imagens para o registro.
Provisione um cluster do AKS e implante os contêineres no cluster.
Teste a implantação.
Crie entidades de serviço para permitir que o GitHub Actions seja implantado no AKS e no Registro de Contêiner do Azure.

Importante

Verifique se você concluiu os pré-requisitos antes de começar.

Abrir o ambiente de desenvolvimento

Você pode optar por usar um codespace do GitHub que hospeda o exercício ou concluí-lo localmente no Visual Studio Code.

Instalação de codespaces do GitHub

Bifurque o repositório https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative-devops em sua própria conta do GitHub. Em seguida, na nova bifurcação:

Selecione Código.
Selecione a guia Codespaces .
Selecione o + ícone para criar seu codespace.

O GitHub leva vários minutos para criar e configurar o codespace. Quando o processo for concluído, você verá os arquivos de código do exercício.

Opcional: Instalação do Visual Studio Code

Para usar o Visual Studio Code, bifurque o https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative-devops repositório em sua própria conta do GitHub e clone-o localmente. Em seguida:

Instale todos os requisitos do sistema para executar o Contêiner de Desenvolvimento no Visual Studio Code.
Confira se o Docker está em execução.
Em uma nova janela do Visual Studio Code, abra a pasta do repositório clonado
Pressione Ctrl+Shift+P para abrir a paleta de comandos.
Pesquisa: >Contêineres de Desenvolvimento: Reconstruir e Reabrir no Contêiner
O Visual Studio Code cria seu contêiner de desenvolvimento localmente.

Construir contêineres

No painel do terminal, execute este comando da CLI dotnet:
```
dotnet publish /p:PublishProfile=DefaultContainer 
```

Criar os recursos do Azure

Na janela do terminal, faça login no Azure com este comando da CLI do Azure:
```
az login --use-device-code
```
Exiba a assinatura do Azure selecionada.
```
az account show -o table
```
Se a assinatura incorreta estiver selecionada, use o comando az account set para selecionar o correto.
Execute o seguinte comando da CLI do Azure para obter uma lista das regiões do Azure e o Nome associado a ele:
```
az account list-locations -o table
```
Localize uma região mais próxima de você e use-a na próxima etapa substituindo [Closest Azure region]
Execute estas instruções bash:
```
export LOCATION=[Closest Azure region]
export RESOURCE_GROUP=rg-eshop
export CLUSTER_NAME=aks-eshop
export ACR_NAME=acseshop$SRANDOM
```
Os comandos anteriores criam variáveis de ambiente que você usará nos próximos comandos da CLI do Azure. Você precisa alterar o LOCAL para uma região do Azure próxima a você; por exemplo, eastus. Se você quiser um nome diferente para seu grupo de recursos, cluster do AKS ou ACR, altere esses valores. Para exibir seus novos repositórios no portal do Azure, atribua a si mesmo a função de Administrador de Automação de Conformidade do Aplicativo no Controle de Acesso (IAM) do registro de contêiner.
Execute estes comandos da CLI do 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
```
Se você receber um erro de autenticação quando az acr login --name $ACR_Name for executado, será necessário ativar o usuário administrador no registro de contêiner recém-criado no Azure em Configurações – Chaves de Acesso. O Azure solicita que você insira essas credenciais para continuar. Você também pode precisar se autenticar novamente com az login --use-device-code.

Esses comandos criam um grupo de recursos para conter os recursos do Azure, um ACR para suas imagens, e em seguida realizam o login no ACR. Pode levar alguns minutos até que você veja esta saída:
```
  ...
  },
  "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 marcar suas imagens e efetuar push delas para o ACR que você criou, execute estes 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

Você pode verificar se o processo de envio das imagens foi concluído com êxito com este comando:

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

Crie seu AKS e conecte-o ao ACR com estes 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
```
Os comandos acima criam um cluster do AKS de nó único, conectam-no ao ACR e, em seguida, conectam sua máquina local ao cluster do AKS. Os comandos acima podem levar alguns minutos para serem concluídos.

Verifique se o novo AKS pode efetuar pull de imagens do ACR com este comando:

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

Você deverá ver uma saída semelhante às seguintes mensagens:

[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!

Agora você pode executar comandos kubectl em seu novo cluster do AKS. Copie o URL completo do ACR a partir da saída; por exemplo, acima do URL está acseshop1251599299.

Verifique o status do cluster do AKS:

kubectl get nodes -A

Você deverá ver um resultado semelhante à seguinte mensagem:

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

Configurar o manifesto de implantação do Kubernetes

Agora as imagens do eShop estão no ACR, você pode atualizar o manifesto de implantação do AKS para usar essas novas imagens.

No Visual Studio Code, no painel EXPLORER, selecione o arquivo deployment.yml na raiz do projeto.

Substitua na linha 17:

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

Cole o nome do ACR copiado da etapa anterior – a linha deve ser semelhante ao seguinte YAML:

- image: acseshop1251599299.azurecr.io/storeimage:v1

Repita estas etapas para a linha 65:

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

Salve o arquivo com CTRL+S.

No painel do terminal, implante um controlador de entrada NGINX com o seguinte comando kubernetes:

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

O comando acima kubectl adiciona serviços e componentes para permitir a entrada no cluster do AKS. Verifique se a entrada está pronta para ser executada usando o seguinte comando kubernetes:

kubectl get services --namespace ingress-nginx

Você deverá ver uma saída semelhante às seguintes mensagens:

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

Implante o aplicativo eShop com este comando:
```
kubectl apply -f deployment.yml
```
O comando kubectl apply implanta o aplicativo eShop, um aplicativo web Blazor de front-end e um serviço de produto API REST de back-end, bem como uma regra de entrada para rotear o tráfego para os serviços corretos no cluster do AKS. Execute este comando novamente se você receber qualquer erro nas implantações.

Você deverá ver uma saída semelhante às seguintes mensagens:
```
deployment.apps/storeimage created
service/eshop-website created
deployment.apps/productservice created
service/eshop-backend created
ingress.networking.k8s.io/eshop-ingress created
```

Verifique se os dois microsserviços foram implantados com este comando:

kubectl get pods -A

Você deverá ver uma saída semelhante às seguintes mensagens:

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

Exiba o eShop implantado com este comando:
```
echo "http://$(kubectl get services --namespace ingress-nginx ingress-nginx-controller --output jsonpath='{.status.loadBalancer.ingress[0].ip}')"
```
O comando acima retorna o endereço IP externo do aplicativo Web. Mantenha pressionada a tecla CTRL e clique no link para abrir o aplicativo em uma nova guia.

Criar uma entidade de serviço para implantar por meio do GitHub

O GitHub Actions pode publicar imagens de contêiner em um Registro de Contêiner do Azure. Portanto, o executor do GitHub deve ter permissões para se conectar ao Azure. As etapas a seguir criam um principal de serviço do Azure AD para atuar como a identidade do GitHub Actions dentro do Azure.

Para salvar sua ID de Assinatura em uma variável de ambiente, execute o seguinte comando no terminal:
```
export SUBS=$(az account show --query 'id' --output tsv)
```

Para criar uma entidade de serviço do Azure AD para permitir o acesso por meio do GitHub, execute o comando a seguir:

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

Uma variação do seguinte resultado é exibida:

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 a saída JSON e os colchetes a serem usados na próxima etapa.

Crie os segredos do GitHub

O executor do GitHub Actions usa credenciais para interagir com o Registro de Contêiner e o AKS. A entidade de serviço e as credenciais para o registro de contêiner são informações confidenciais. É melhor armazenar informações confidenciais como segredos criptografados em um local seguro. O GitHub fornece um local interno para armazenar segredos e outras variáveis.

Conclua as etapas a seguir para armazenar com segurança as informações confidenciais como variáveis de ambiente em seu repositório. Os administradores do repositório devem gerenciar os segredos que o executor do GitHub Actions pode acessar.

No repositório do GitHub bifurcado, acesse Settings>Secrets and variables>Actions.
Na página Actions secrets and variables, selecione New repository secret.
New secret Na página, em Name, insira AZURE_CREDENTIALS e, em Secret, insira a saída JSON que você copiou do terminal.

As configurações devem ser semelhantes à seguinte captura de tela:
Selecione Add secret.

Você usará esse segredo do GitHub na próxima seção para criar uma ação do GitHub para criar a imagem de contêiner.

Implantar manualmente seu aplicativo nativo de nuvem no Serviço de Kubernetes do Azure

Abrir o ambiente de desenvolvimento

Instalação de codespaces do GitHub

Opcional: Instalação do Visual Studio Code

Construir contêineres

Criar os recursos do Azure

Configurar o manifesto de implantação do Kubernetes

Criar uma entidade de serviço para implantar por meio do GitHub

Crie os segredos do GitHub

Comentários