Exercício – Configurar seu ambiente do Azure DevOps

25 minutos

Nesta seção, você configurará sua organização do Azure DevOps para continuar com o restante deste módulo e criar um ambiente do AKS (Serviço de Kubernetes do Azure) para implantar seu aplicativo.

Para alcançar esses objetivos, você terá:

Adicione um usuário à sua organização do Azure DevOps.
Configure seu projeto do Azure DevOps.
Gerencie seu fluxo de trabalho com o Azure Boards.
Criar recursos do Azure usando a CLI do Azure.
Crie variáveis de pipeline no Azure Pipelines.
Crie uma conexão de serviço para autenticar com o Azure.
Atualize o manifesto de implantação do Kubernetes.

Adicionar um usuário à sua organização

Para concluir este módulo, uma assinatura do Azure é necessária. Você pode começar a usar o Azure gratuitamente.

Embora não seja necessário trabalhar com o Azure DevOps, uma assinatura do Azure é necessária para implantar nos recursos do Azure por meio do Azure DevOps. Para tornar o processo mais simples, use a mesma conta da Microsoft para entrar em sua assinatura do Azure e em sua organização do Azure DevOps.

Se você entrar no Azure e no Azure DevOps usando diferentes contas da Microsoft, ainda poderá continuar adicionando um usuário à sua organização do DevOps na conta da Microsoft associada à sua assinatura do Azure. Consulte Adicionar usuários à sua organização ou projeto para obter mais detalhes. Ao adicionar o usuário, selecione o nível de acesso Básico .

Depois de adicionar o usuário com o nível de acesso Básico, saia do Azure DevOps e entre novamente usando a conta da Microsoft associada à sua assinatura do Azure.

Obter o projeto do Azure DevOps

Nesta seção, você executará um modelo para criar seu projeto no Azure DevOps.

Executar o modelo

Execute um modelo que configure sua organização do Azure DevOps.

Importante

O Gerador de Demonstração do Azure DevOps não tem mais suporte, mas você ainda pode usá-lo para criar ambientes de demonstração. Atualmente, não há nenhum substituto, e seus recursos ou disponibilidade podem mudar no futuro.

Obtenha e execute o projeto ADOGenerator no Visual Studio ou o IDE de sua escolha.
Quando solicitado a inserir o número do modelo na lista de modelos, insira40 para automatizar implantações de vários contêineres nos Serviços de Kubernetes do Azure com o Azure Pipelines e pressione Enter.
Escolha seu método de autenticação. Você pode configurar e usar um PAT (Token de Acesso Pessoal) ou usar o logon do dispositivo.

Observação

Se você configurar um PAT, certifique-se de autorizar os escopos necessários. Para este módulo, você pode usar o acesso completo, mas em uma situação real, você deve garantir que conceda apenas os escopos necessários.
Insira o nome da sua organização do Azure DevOps e pressione Enter.
Se solicitado, insira o PAT do Azure DevOps e pressione Enter.
Insira um nome de projeto como Space Game – Web – Kubernetes e pressione Enter.
Depois que o projeto for criado, acesse sua organização do Azure DevOps no navegador (em https://dev.azure.com/<your-organization-name>/) e selecione o projeto.

Bifurcar o repositório

Caso ainda não tenha feito isso, crie uma bifurcação do repositório mslearn-tailspin-spacegame-web-kubernetes .

No GitHub, acesse o repositório mslearn-tailspin-spacegame-web-kubernetes .
Selecione Fork no canto superior direito da tela.
Escolha sua conta do GitHub como Owner e, em seguida, selecione Criar fork.

Importante

A unidade Limpar seu ambiente do Azure DevOps neste módulo inclui etapas cruciais para limpeza. É recomendável executar essas etapas para evitar acabar com os minutos de build gratuitos. Mesmo que você não conclua este módulo, é importante seguir as etapas de limpeza.

Definir a visibilidade do projeto

Inicialmente, o fork do repositório Space Game no GitHub é definido como público, ao passo que o projeto criado pelo modelo do Azure DevOps é definido como privado. Um repositório público no GitHub pode ser acessado por qualquer pessoa, enquanto um repositório privado só é acessível para você e para as pessoas com quem você escolhe compartilhá-lo. Da mesma forma, no Azure DevOps, os projetos públicos fornecem acesso somente leitura a usuários não autenticados, enquanto projetos privados exigem que os usuários tenham acesso e sejam autenticados para acessar os serviços.

No momento, não é necessário modificar nenhuma dessas configurações para os fins deste módulo. No entanto, em seus projetos pessoais, você precisa determinar a visibilidade e o acesso que deseja permitir às outras pessoas. Por exemplo, se o projeto for de código aberto, você poderá optar por tornar o repositório GitHub e o projeto do Azure DevOps públicos. Se o projeto for proprietário, normalmente, você tornará o repositório GitHub e o projeto do Azure DevOps privados.

Mais adiante você poderá se interessar pelos seguintes recursos para determinar qual opção é melhor para seu projeto:

Mover o item de trabalho para Executando

Nesta etapa, você atribui um item de trabalho a si mesmo no Azure Boards e o move para o estado Doing . Em cenários reais, você e sua equipe criariam itens de trabalho no início de cada sprint ou iteração de trabalho.

A atribuição de itens de trabalho fornece uma lista de verificação da qual trabalhar e dá a outros membros da equipe visibilidade do seu progresso e do trabalho restante. Ele também ajuda a impor limites de WIP (trabalho em andamento) para impedir que a equipe tenha muito trabalho ao mesmo tempo.

Navegue até Boards no Azure DevOps e selecione Boards no menu.
Atribua o item de trabalho Criar versão de vários contêineres do site orquestrado com o Kubernetes a si mesmo selecionando a seta para baixo na parte inferior do cartão.
Arraste e solte o item de trabalho da coluna To Do para a coluna Doing . Você moverá a tarefa para a coluna Concluído no final deste módulo depois de concluí-la.

Criar o ambiente do Serviço de Kubernetes do Azure

Nesta etapa, você criará os recursos necessários do Serviço de Kubernetes do Azure para implantar a nova versão de contêiner do site.

Neste módulo, você usará a CLI do Azure para criar os recursos necessários para implantar e executar seu aplicativo no Serviço de Kubernetes do Azure. A CLI do Azure pode ser acessada de um terminal ou por meio do Visual Studio Code. No entanto, neste módulo, você acessa a CLI do Azure do Azure Cloud Shell. O Cloud Shell é uma experiência de shell baseada em navegador hospedada na nuvem, que vem pré-configurada com a CLI do Azure para uso com sua assinatura do Azure.

Importante

Para concluir os exercícios neste módulo, você precisa de sua própria assinatura do Azure.

Iniciar o Cloud Shell

Navegue até o portal do Azure e entre.
Selecione a opção Cloud Shell no menu e escolha a experiência Bash quando solicitado.

Observação

O Cloud Shell exige um recurso de Armazenamento do Azure para manter todos os arquivos que você criar no Cloud Shell. Ao abrir o Cloud Shell pela primeira vez, você precisará criar um grupo de recursos, uma conta de armazenamento e um compartilhamento de Arquivos do Azure. Essa configuração é usada automaticamente para todas as sessões futuras do Cloud Shell.

Selecionar uma região do Azure

Uma região refere-se a um ou mais datacenters do Azure localizados em uma área geográfica. Regiões como Leste dos EUA, Oeste dos EUA e Norte da Europa são exemplos dessas áreas. Cada recurso do Azure, incluindo uma instância do Serviço de Aplicativo, é associado a uma região.

Para simplificar a execução de comandos, comece definindo uma região padrão. Depois de definir uma região padrão, os comandos subsequentes usam essa região por padrão, a menos que você especifique explicitamente uma região diferente.

No Cloud Shell, execute o seguinte comando para listar as regiões disponíveis em sua assinatura do Azure:
```
az account list-locations \
  --query "[].{Name: name, DisplayName: displayName}" \
  --output table
```
Selecione uma região na coluna Nome na saída que está geograficamente próxima a você. Por exemplo, você pode escolher eastasia ou westus2.
Execute o comando a seguir para definir sua região padrão. Substitua REGION pelo nome da região escolhida anteriormente.
```
az configure --defaults location=<REGION>
```
Este exemplo define westus2 como a região padrão.
```
az configure --defaults location=westus2
```

Criar variáveis bash

O uso de variáveis Bash pode tornar o processo de instalação mais conveniente e menos propenso a erros. Essa abordagem ajuda a evitar erros de digitação acidentais definindo cadeias de caracteres de texto compartilhadas como variáveis que podem ser usadas em todo o script.

No Cloud Shell, gere um número aleatório para simplificar a criação de nomes globalmente exclusivos para determinados serviços na próxima etapa.
```
resourceSuffix=$RANDOM
```
Crie nomes globalmente exclusivos para o Registro de Contêiner do Azure e a instância do Serviço de Kubernetes do Azure. Observe que esses comandos usam aspas duplas, que instruem o Bash a interpolar as variáveis usando a sintaxe embutida.
```
registryName="tailspinspacegame${resourceSuffix}"
aksName="tailspinspacegame-${resourceSuffix}"
```
Crie outra variável Bash para armazenar o nome do grupo de recursos.
```
rgName='tailspin-space-game-rg'
```
Localize a versão mais recente do AKS.
```
az aks get-versions
```
Anote a versão mais recente.

Criar recursos do Azure

Observação

Neste tutorial, as configurações de rede padrão são usadas para fins de aprendizado. Essas configurações permitem que seu site seja acessado pela Internet. No entanto, na prática, você pode optar por configurar uma rede virtual do Azure que coloca seu site em uma rede que não é roteável pela Internet e só é acessível por você e sua equipe. Posteriormente, você poderá reconfigurar sua rede para disponibilizar o site para seus usuários.

Execute o seguinte comando para criar um grupo de recursos com o nome que você definiu anteriormente:
```
az group create --name $rgName
```
Execute o az acr create comando para criar um Registro de Contêiner do Azure com o nome definido anteriormente:
```
az acr create \
  --name $registryName \
  --resource-group $rgName \
  --sku Standard
```
Execute o az aks create comando para criar uma instância do AKS com o nome que você definiu anteriormente. Substitua <latest-AKS-version> pela versão que você anotou anteriormente.
```
az aks create \
  --name $aksName \
  --resource-group $rgName \
  --enable-addons monitoring \
  --kubernetes-version <latest-AKS-version> \
  --generate-ssh-keys
```
Observação

A conclusão da implantação do AKS pode levar de 10 a 15 minutos.

Crie uma variável para armazenar o ID do serviço principal configurado para a instância do AKS.

clientId=$(az aks show \
  --resource-group $rgName \
  --name $aksName \
  --query "identityProfile.kubeletidentity.clientId" \
  --output tsv)

Crie uma variável para armazenar a ID do Registro de Contêiner do Azure:

acrId=$(az acr show \
  --name $registryName \
  --resource-group $rgName \
  --query "id" \
  --output tsv)

Execute o az acr list comando para recuperar a URL do servidor de logon para sua instância do ACR (Registro de Contêiner do Azure):
```
az acr list \
 --resource-group $rgName \
 --query "[].{loginServer: loginServer}" \
 --output table
```
Lembre-se de anotar o servidor de logon do registro de contêiner. Você precisará dessas informações mais tarde ao configurar o pipeline. Veja um exemplo:
```
LoginServer                      
--------------------------------
tailspinspacegame4692.azurecr.io
```
Execute o az role assignment create comando para criar uma atribuição de função para autorizar o cluster do AKS a se conectar ao Registro de Contêiner do Azure:
```
az role assignment create \
  --assignee $clientId \
  --role AcrPull \
  --scope $acrId
```

Importante

A unidade Limpar seu ambiente do Azure DevOps neste módulo inclui etapas cruciais para limpeza. É recomendável executar essas etapas para evitar esgotar os minutos gratuitos de build. Mesmo que você não conclua este módulo, é importante seguir as etapas de limpeza.

Criar um grupo de variáveis

Nesta seção, você adicionará uma variável ao pipeline para armazenar o nome do Registro de Contêiner do Azure. É recomendável definir o nome da instância do Registro de Contêiner do Azure como uma variável em sua configuração de pipeline em vez de codificá-la. Isso torna sua configuração mais reutilizável e, caso o nome da instância mude, você pode atualizar facilmente a variável e disparar o pipeline sem precisar modificar sua configuração.

Entre em sua organização do Azure DevOps e navegue até seu projeto.
Selecione Pipelines e, em seguida, selecione Biblioteca no painel de navegação esquerdo.
Selecione Grupos de variáveis e selecione + Grupo de variáveis para adicionar um novo grupo de variáveis.
Na seção Propriedades , insira Release para o nome do grupo de variáveis.
Na seção Variáveis , selecione Adicionar.
Insira RegistryName para o nome da variável e, para o valor, insira o servidor de logon do Registro de Contêiner do Azure, como tailspinspacegame4692.azurecr.io.
Na parte superior da página, selecione Salvar para salvar sua variável de pipeline. Este é um exemplo da aparência do grupo de variáveis

Criar conexões de serviço

A próxima etapa é criar conexões de serviço que permitem que o Azure Pipelines acesse o Registro de Contêiner do Azure e as instâncias do Serviço de Kubernetes do Azure. Criando essas conexões de serviço, o Azure Pipelines pode efetuar push para os contêineres e instruir o cluster do AKS a efetuar pull deles para atualizar o serviço implantado.

Importante

Verifique se você está conectado ao portal do Azure e ao Azure DevOps com a mesma conta da Microsoft.

Criar uma conexão de serviço do Registro do Docker

Entre em sua organização do Azure DevOps e navegue até seu projeto.
Selecione as configurações do Projeto no canto inferior da página.
Selecione conexões de serviço na seção Pipelines .
Selecione Nova conexão de serviço, selecione o Registro do Docker e, em seguida, selecione Avançar.
Próximo à parte superior da página, selecione Registro de Contêiner do Azure e Entidade de Serviço para o tipo de autenticação.

Insira os seguintes valores para cada configuração:

Configurações	Valor
Subscrição	Sua assinatura do Azure
Registro de Contêiner do Azure	Selecione o que você criou anteriormente
Nome da conexão de serviço	Conexão do Registro de Contêiner

Verifique se a caixa de seleção para Conceder permissão de acesso a todos os pipelines está selecionada.
Selecione Salvar ao terminar.

Criar conexão de serviço do ARM

Agora você criará uma conexão de serviço do Azure Resource Manager para autenticar com o cluster do AKS. Estamos usando uma conexão de serviço ARM em vez do Kubernetes porque tokens de longa duração não são mais criados por padrão desde o Kubernetes 1.24. Confira esta postagem no blog do DevOps para obter mais detalhes: Diretrizes de conexão de serviço para clientes do AKS que usam tarefas do Kubernetes.

Selecione Nova conexão de serviço, Azure Resource Manager e Avançar.
Escolha Entidade de Serviço (automática) e Avançar.
Selecione Assinatura para o nível de escopo.

Insira os valores a seguir para cada configuração.

Configurações	Valor
Subscrição	Sua assinatura do Azure
Grupo de recursos	Selecione o que você criou anteriormente
Nome da conexão de serviço	Conexão de cluster do Kubernetes

Verifique se a caixa de seleção para Conceder permissão de acesso a todos os pipelines está selecionada.
Selecione Salvar ao terminar.

Criar um ambiente de pipeline

Selecione Pipelines e selecione Ambientes.
Selecione Criar ambiente para criar um novo ambiente.
No campo Nome , insira Dev.
Selecione Nenhum na seção Recurso e, em seguida, selecione Criar para criar seu ambiente de pipeline.

Atualizar o manifesto de implantação do Kubernetes

Nesta seção, você atualizará o manifesto do Kubernetes deployment.yml para apontar para o registro de contêiner criado anteriormente.

Navegue até sua conta do GitHub e escolha o repositório que você fez fork para este módulo: mslearn-tailspin-spacegame-web-kubernetes.
Abra o arquivo de manifestos/deployment.yml no modo de edição.

Altere as referências de imagem de contêiner para usar o servidor de logon do ACR. O manifesto a seguir usa tailspinspacegame2439.azurecr.io como exemplo.

apiVersion : apps/v1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 1
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
        - name: web
          image: tailspinspacegame4692.azurecr.io/web
          ports:
          - containerPort: 80

apiVersion : apps/v1
kind: Deployment
metadata:
  name: leaderboard
spec:
  replicas: 1
  selector:
    matchLabels:
      app: leaderboard
  template:
    metadata:
      labels:
        app: leaderboard
    spec:
      containers:
        - name: leaderboard
          image: tailspinspacegame4692.azurecr.io/leaderboard
          ports:
          - containerPort: 80

Confirme as alterações no branch main.

Comentários

Esta página foi útil?