Exercício - Configurar seu ambiente de DevOps do Azure

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 Serviço Kubernetes do Azure (AKS) para implantar seu aplicativo.

Para alcançar estes objetivos, irá:

Adicione um usuário à sua organização do Azure DevOps.
Configure seu projeto de DevOps do Azure.
Gerencie seu fluxo de trabalho com os Painéis do Azure.
Crie 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 seu manifesto de implantação do Kubernetes.

Adicionar um utilizador à sua organização

Para concluir este módulo, é necessária uma subscrição do Azure. Pode começar a utilizar 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 na sua assinatura do Azure e na sua organização do Azure DevOps.

Se você entrar no Azure e no Azure DevOps usando contas da Microsoft diferentes, ainda poderá continuar adicionando um usuário à sua organização de DevOps na conta da Microsoft associada à sua assinatura do Azure. Consulte Adicionar utilizadores à 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.

Obtenha o projeto Azure DevOps

Nesta seção, você executa 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 é mais suportado, mas você ainda pode usá-lo para criar ambientes de demonstração. Atualmente, não há substituição, e seus recursos ou disponibilidade podem mudar no futuro.

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

Observação

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

Fazer fork do repositório

Se ainda não o fez, crie uma bifurcação do repositório mslearn-tailspin-spacegame-web-kubernetes .

No GitHub, vá para o repositório mslearn-tailspin-spacegame-web-kubernetes .
Selecione Forquilha no canto superior direito da tela.
Escolha sua conta do GitHub como Proprietário e, em seguida, selecione Criar bifurcação.

Importante

A unidade Limpar seu ambiente de DevOps do Azure neste módulo inclui etapas cruciais para limpeza. Recomenda-se executar estas etapas para evitar ficar sem minutos de compilação gratuitos. Mesmo que não termine este módulo, é importante seguir os passos de limpeza.

Defina a visibilidade do seu projeto

Inicialmente, sua bifurcação do repositório do Jogo Espacial no GitHub é definida como pública, enquanto o projeto criado pelo modelo de DevOps do Azure é 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ê escolher compartilhá-lo. Da mesma forma, no Azure DevOps, os projetos públicos fornecem acesso somente leitura a usuários não autenticados, enquanto os projetos privados exigem que os usuários recebam 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, para seus projetos pessoais, você deve determinar a visibilidade e o acesso que deseja conceder a outras pessoas. Por exemplo, se seu projeto for de código aberto, você pode optar por tornar público o repositório do GitHub e o projeto do Azure DevOps. Se seu projeto for proprietário, você normalmente tornará o repositório do GitHub e o projeto do Azure DevOps privados.

Mais tarde, você pode achar os seguintes recursos úteis para determinar qual opção é melhor para o seu projeto:

Mover o item de trabalho para Em Progresso

Nesta etapa, você atribui um item de trabalho a si mesmo nos Quadros do Azure e move-o para o estado Fazendo. Em cenários do mundo real, 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 para trabalhar e dá a outros membros da equipe visibilidade sobre seu progresso e trabalho restante. Ele também ajuda a impor limites de trabalho em andamento (WIP) para evitar que a equipe assuma muito trabalho ao mesmo tempo.

Navegue até Painéis no Azure DevOps e selecione Painéis no menu.
Atribua o item de trabalho Criar versão multicontentor do website gerido com Kubernetes a si próprio, selecionando a seta para baixo localizada na parte inferior do cartão.
Arraste e solte o item de trabalho da coluna Fazer para a coluna Fazendo. Você moverá a tarefa para a coluna Concluído no final deste módulo depois de concluí-la.

Criar o ambiente do Serviço Kubernetes do Azure

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

Neste módulo, você usa a CLI do Azure para criar os recursos necessários para implantar e executar seu aplicativo no Serviço 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.

Inicie o Cloud Shell

Aceda ao portal do Azure e inicie sessão.
Selecione a opção Cloud Shell no menu e, em seguida, escolha a experiência Bash quando solicitado.

Observação

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

Selecione 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 o Leste dos EUA, o Oeste dos EUA e o Norte da Europa são exemplos dessas áreas. Cada recurso do Azure, incluindo uma instância do Serviço de Aplicativo, está 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 da coluna Nome na saída que está geograficamente próxima de si. Por exemplo, você pode escolher eastasia ou westus2.
Execute o seguinte comando para definir sua região padrão. Substitua REGIÃO 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 configuração mais conveniente e menos propenso a erros. Essa abordagem ajuda a evitar erros de digitação acidentais definindo cadeias de texto compartilhadas como variáveis que podem ser usadas em todo o script.

A partir do 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 seu Registro de Contêiner do Azure e instância do Serviço Kubernetes do Azure. Observe que esses comandos usam aspas duplas, que instruem 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 seu grupo de recursos.
```
rgName='tailspin-space-game-rg'
```
Encontre 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 aprendizagem. Estas definições permitem que o seu website seja acedido a partir da 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. Mais tarde, você pode reconfigurar sua rede para disponibilizar o site para seus usuários.

Execute o seguinte comando para criar um grupo de recursos com o nome definido anteriormente:
```
az group create --name $rgName
```
Execute o comando az acr create 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 comando az aks create para criar uma instância do AKS com o nome definido 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 a ID da entidade de serviço configurada para a instância 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 comando az acr list para recuperar a URL do servidor de logon para sua instância do Azure Container Registry (ACR):
```
az acr list \
 --resource-group $rgName \
 --query "[].{loginServer: loginServer}" \
 --output table
```
Certifique-se de tomar nota do servidor de login para seu registro de contêiner. Você precisará dessas informações mais tarde ao configurar seu pipeline. Aqui está um exemplo:
```
LoginServer                      
--------------------------------
tailspinspacegame4692.azurecr.io
```
Execute o comando az role assignment create para criar uma atribuição de função para autorizar o cluster AKS a se conectar ao Registro de Contêiner do Azure:
```
az role assignment create \
  --assignee $clientId \
  --role AcrPull \
  --scope $acrId
```

Importante

Criar um grupo de variáveis

Nesta seção, você adicionará uma variável ao seu pipeline para armazenar o nome do seu Registro de Contêiner do Azure. Recomenda-se definir o nome da instância do Registro de Contêiner do Azure como uma variável na configuração do 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 acionar o pipeline sem precisar modificar a configuração.

Entre em sua organização do Azure DevOps e navegue até seu projeto.
Selecione Pipelinese, em seguida, selecione Biblioteca no painel de navegação esquerdo.
Selecione Grupos de variáveise, em seguida, selecione + Grupo de variáveis para adicionar um novo grupo de variáveis.
Na seção Propriedades, insira de versão 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 login do seu Azure Container Registry, como tailspinspacegame4692.azurecr.io.
Na parte superior da página, selecione Salvar para guardar a variável de pipeline. Este é um exemplo de como seu grupo variável pode parecer

Criar conexões de serviço

A próxima etapa é criar conexões de serviço que permitam que o Azure Pipelines acesse seu Registro de Contêiner do Azure e instâncias do Serviço Kubernetes do Azure. Ao criar essas conexões de serviço, o Azure Pipelines pode enviar seus contêineres por push e instruir seu cluster AKS a obtê-los para atualizar o serviço implantado.

Importante

Certifique-se de que esteja autenticado no portal do Azure e no Azure DevOps com a mesma conta 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 de 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çoe, em seguida, selecione Registro do Dockere, em seguida, selecione Avançar.
Perto do topo da página, selecione Registo de Contentor do Azuree, em seguida, para o tipo de autenticação, selecione Principal do Serviço.

Insira os seguintes valores para cada configuração:

Cenário	Valor
Subscrição	A sua subscrição 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 opção Conceder permissão de acesso a todos os pipelines está selecionada.
Selecione Salvar quando terminar.

Criar conexão de serviço ARM

Agora você criará uma conexão de serviço do Azure Resource Manager para autenticar com seu cluster AKS. Estamos usando uma conexão de serviço ARM em vez do Kubernetes porque os tokens de longa duração não são mais criados por padrão desde o Kubernetes 1.24. Confira esta publicação do blog DevOps para obter mais detalhes: Orientações de Conexão de Serviço para clientes AKS que utilizam tarefas do Kubernetes.

Selecione Nova conexão de serviço, selecione do Azure Resource Manager e selecione Avançar.
Selecione Principal de Serviço (automático)e, em seguida, selecione Seguinte.
Selecione a Subscrição para o nível de âmbito.

Insira os seguintes valores para cada configuração.

Cenário	Valor
Subscrição	A sua subscrição do Azure
Grupo de recursos	Selecione o que você criou anteriormente
Nome da conexão de serviço	Conexão ao Cluster Kubernetes

Verifique se a opção Conceder permissão de acesso a todos os pipelines está selecionada.
Selecione Salvar quando terminar.

Criar um ambiente de pipeline

Selecione Pipelinese, em seguida, selecione Environments.
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 o 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 selecione o repositório bifurcado para este módulo: mslearn-tailspin-spacegame-web-kubernetes.
Abra o arquivo manifestos/deployment.yml no modo de edição.

Altere as referências de imagem de contêiner para usar seu servidor de login 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 na sua ramificação main.

Feedback

Esta página foi útil?