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

8 minutos

Antes de automatizar as implantações do seu site, você precisará implantar manualmente o aplicativo existente do eShop no AKS (Serviço de Kubernetes do Azure). Você criará os recursos do Azure e implantará o aplicativo no AKS usando os comandos da CLI do Azure e scripts do 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, em seguida, envie as imagens por push 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.

Configuração dos GitHub Codespaces

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.
Escolha 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: Configuração do Visual Studio Code

Para usar o Visual Studio Code, crie um fork do repositório https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative-devops 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.

Compilar contêineres

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

Criar os recursos do Azure

No painel de terminal, entre no Azure com este comando da CLI do Azure:
```
az login --use-device-code
```
Veja a assinatura do Azure selecionada.
```
az account show -o table
```
Se a assinatura incorreta estiver selecionada, selecione a correta usando o comando az account set.
Execute o seguinte comando da CLI do Azure para obter uma lista de regiões do Azure e o Nome associado a ela:
```
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 desejar 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 de Aplicativo no Controle de acesso (IAM) do registro de contêiner.
Execute 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, você precisa ativar o Usuário administrador no registro de contêiner recém-criado no Azure em Configurações – Chaves de Acesso. O Azure solicitará 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, fazem login no ACR. Pode levar alguns minutos até que você ver 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 enviá-las por push 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 as imagens foram concluídas com sucesse 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 o 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 uma saída semelhante às seguintes mensagens:

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

Configure o manifesto de implantação do Kubernetes

Agora que 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 essas etapas na 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 do kubernetes:

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

O comando kubectl acima 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 do 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 novamente este comando se você receber algum erro em 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 estão 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

Veja a eShop implantada 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. O executor do GitHub, portanto, deve possuir permissões para se conectar ao Azure. As etapas a seguir criam uma entidade 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 comando a seguir 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 para usar 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.

Realize as etapas a seguir para armazenar com segurança as informações confidenciais como variáveis de ambiente em seu repositório. Os administradores de 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.
Na página New secret, em Name, insira AZURE_CREDENTIALS e, em Secret, insira a saída JSON que você copiou do terminal.

As configurações devem ter aparência semelhante à 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 que criará a imagem de contêiner.

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

Abrir o ambiente de desenvolvimento

Configuração dos GitHub Codespaces

Opcional: Configuração do Visual Studio Code

Compilar contêineres

Criar os recursos do Azure

Configure 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