0Pricing
Cloud & IT Cert Prep · Aula

Fluxo de trabalho do desenvolvedor de ponta a ponta

Conecte o CI/CD do GitHub Actions, o Azure Container Registry, o Container Apps e o Application Insights em um ciclo interno completo do desenvolvedor, do commit à produção observável.

Fluxo de trabalho do desenvolvedor de ponta a ponta é uma aula grátis de Cloud & IT Cert Prep no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Cloud & IT Cert Prep, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Cloud & IT Cert Prep inclui 4 aulas no total.

O ciclo moderno de desenvolvimento no Azure

Um fluxo de trabalho moderno de desenvolvimento no Azure conecta o controle de código-fonte, a CI/CD, a infraestrutura de contêineres e a observabilidade em um ciclo interno contínuo, desde o commit do código até uma produção observável. Os principais componentes são: GitHub (código-fonte), GitHub Actions (pipeline de compilação e implantação), Azure Container Registry (armazenamento de imagens), Azure Container Apps (ambiente de execução) e Application Insights (observabilidade). Cada alteração passa automaticamente do computador do desenvolvedor para a produção em poucos minutos, com gates de qualidade em cada etapa.

Etapa 1: controle de código-fonte e estratégia de ramificação

Organize seu código em um repositório do GitHub usando desenvolvimento baseado em tronco ou uma estratégia de ramificação GitFlow. Para a maioria dos microsserviços, o desenvolvimento baseado em tronco (ramificações de funcionalidades de curta duração mescladas diariamente à main) reduz conflitos de integração e mantém o pipeline simples. Use regras de proteção de ramificação na main para exigir revisões de solicitações de pull e verificações de CI aprovadas antes da mesclagem. Um arquivo CODEOWNERS garante que alterações em serviços críticos exijam a aprovação dos engenheiros seniores da equipe responsável.

# Example .github/CODEOWNERS
# Require payments-team review for any changes under /src/payments/
/src/payments/ @payments-team
/infrastructure/   @platform-team

Etapa 2: CI com GitHub Actions

O pipeline de CI é executado em cada solicitação de pull. Um fluxo de trabalho típico é: baixar o código → restaurar dependências → executar testes unitários → executar testes de integração → compilar a imagem do Docker → enviar para o Azure Container Registry. A imagem recebe uma etiqueta com o SHA do commit do git para permitir o rastreamento. Use autenticação baseada em OIDC do GitHub Actions para o Azure (por meio de identidade federada) para evitar armazenar segredos de entidades de serviço do Azure no GitHub — um equivalente de identidade gerenciada para pipelines de CI.

# .github/workflows/ci.yml (abbreviated)
name: CI
on: [pull_request]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Login to ACR
        uses: azure/docker-login@v1
        with:
          login-server: myacr.azurecr.io
          username: ${{ secrets.AZURE_CLIENT_ID }}
          password: ${{ secrets.AZURE_CLIENT_SECRET }}
      - name: Build and push image
        run: |
          docker build -t myacr.azurecr.io/myapi:${{ github.sha }} .
          docker push myacr.azurecr.io/myapi:${{ github.sha }}

Etapa 3: CD para o ambiente de preparação

Depois que o pipeline de CI é concluído com êxito após uma mesclagem na main, o pipeline de CD implanta automaticamente no ambiente de preparação. O pipeline atualiza a etiqueta da imagem do Container App para o SHA recém-compilado, aguarda a nova revisão ficar íntegra e executa testes de fumaça no URL de preparação. Os testes de fumaça verificam se os pontos de extremidade críticos da API retornam as respostas esperadas. Se os testes de fumaça falharem, o pipeline reverte a alteração direcionando novamente o tráfego de entrada para a revisão anterior, sem nenhuma intervenção manual.

# CD stage: update Container App to new image
- name: Deploy to staging
  uses: azure/cli@v2
  with:
    azcliversion: latest
    inlineScript: |
      az containerapp update \
        --name myapi-staging \
        --resource-group myRG \
        --image myacr.azurecr.io/myapi:${{ github.sha }}

- name: Run smoke tests
  run: |
    STAGING_URL=$(az containerapp show --name myapi-staging \
      --resource-group myRG \
      --query 'properties.configuration.ingress.fqdn' -o tsv)
    curl -f https://$STAGING_URL/health || exit 1

Etapa 4: gate de aprovação para produção

Após a validação no ambiente de preparação, o pipeline de CD pausa em um gate de aprovação. As proteções de ambiente do GitHub Actions permitem configurar revisores obrigatórios para o ambiente de production. O pipeline envia uma notificação do Slack ao engenheiro de plantão, que analisa os resultados dos testes de preparação, as diferenças e quaisquer incidentes em aberto antes de aprovar. Somente após a aprovação o pipeline prossegue para implantar a mesma imagem SHA em produção. Essa etapa com participação humana é essencial para serviços de alto tráfego ou regulamentados.

# In GitHub: create 'production' environment with required reviewers
# .github/workflows/cd.yml (abbreviated)
jobs:
  deploy-production:
    environment:
      name: production
      url: https://myapi.contoso.com
    needs: deploy-staging
    steps:
      - name: Deploy to production
        uses: azure/cli@v2
        with:
          inlineScript: |
            az containerapp update \
              --name myapi \
              --resource-group myRG \
              --image myacr.azurecr.io/myapi:${{ github.sha }}

Etapa 5: observabilidade da produção

Depois da implantação em produção, o Application Insights oferece visibilidade em tempo real. O SDK do App Insights (ou a instrumentação automática para ambientes de execução compatíveis) acompanha: taxas de solicitações, taxas de falha e latência (os três sinais dourados), chamadas de dependência (para bancos de dados, Service Bus e outras APIs) e exceções com rastreamentos completos da pilha. O Mapa de Aplicações visualiza como os serviços chamam uns aos outros e destaca quais dependências contribuem mais para falhas ou latência.

# Python: Add Application Insights SDK
from opencensus.ext.azure.log_exporter import AzureLogHandler
from opencensus.ext.azure.trace_exporter import AzureExporter
from opencensus.trace.samplers import ProbabilitySampler
from opencensus.trace.tracer import Tracer

tracer = Tracer(
  exporter=AzureExporter(connection_string='InstrumentationKey=<key>'),
  sampler=ProbabilitySampler(1.0)
)

Conectando implantações aos rastreamentos

Use anotações do Application Insights para marcar eventos de implantação nos gráficos de métricas. Quando uma anotação de versão é criada (por meio da ação azure/appinsights-annotation do GitHub Actions), ela aparece como uma linha vertical em todos os gráficos de métricas do App Insights. Isso torna imediatamente evidente se um aumento de latência ou da taxa de erros está correlacionado com uma implantação recente, reduzindo significativamente o tempo médio para diagnosticar (MTTD) incidentes.

# Create a release annotation in Application Insights
- name: Annotate release in App Insights
  uses: azure/appinsights-annotation@v1
  with:
    appInsightsResourceName: myAppInsights
    resourceGroupName: myRG
    releaseName: '${{ github.run_id }}-${{ github.sha }}'

Reversão automática diante de um aumento na taxa de erros

Para os pipelines mais resilientes, implemente a reversão automática. Após a implantação em produção, o pipeline aguarda 10 minutos e consulta o Application Insights para obter a taxa de erros. Se a taxa de erros exceder um limite configurável (por exemplo, >5%), o pipeline reverte automaticamente a alteração, atualizando o tráfego de entrada do Container App para direcionar 100% à revisão anterior. Esse padrão de entrega progressiva reduz o raio de impacto de uma implantação problemática e permite que as equipes implantem com confiança, mesmo no caso de alterações complexas ou sensíveis.

# Query App Insights error rate via REST (abbreviated)
QUERY='requests | where timestamp > ago(10m) | summarize failed = countif(success == false), total = count() | extend errorRate = round(100.0 * failed / total, 2)'
RESULT=$(az monitor app-insights query \
  --apps myAppInsights \
  --resource-group myRG \
  --analytics-query "$QUERY" \
  --query 'tables[0].rows[0][2]' -o tsv)
if [ $(echo '$RESULT > 5' | bc -l) -eq 1 ]; then
  echo 'Error rate $RESULT% - rolling back!'
  az containerapp ingress traffic set --name myapi --resource-group myRG --revision-weight stable=100
fi

Produtividade do desenvolvedor: desenvolvimento local com emuladores

Os desenvolvedores devem poder executar e testar toda a pilha localmente, sem se conectar aos recursos do Azure em produção. Use o Azure Storage Emulator (Azurite) para armazenamento local de blobs e filas, o Cosmos DB Emulator para testes locais de banco de dados e o Service Bus Emulator para mensagens locais. A variável de ambiente AZURE_ENVIRONMENT=local pode alternar o DefaultAzureCredential para usar cadeias de conexão apontando para emuladores, enquanto o mesmo código usa identidade gerenciada no Azure. O Docker Compose orquestra todas as dependências locais em um único comando docker compose up.

# docker-compose.yml for local development
services:
  azurite:
    image: mcr.microsoft.com/azure-storage/azurite
    ports:
      - '10000:10000'
      - '10001:10001'
  cosmos-emulator:
    image: mcr.microsoft.com/cosmosdb/linux/azure-cosmos-emulator
    ports:
      - '8081:8081'

Segurança no fluxo de trabalho do desenvolvedor

Integre a segurança a cada etapa do fluxo de trabalho do desenvolvedor: o Dependabot verifica dependências vulneráveis em solicitações de pull; o GitHub Advanced Security (verificação de código com CodeQL) detecta vulnerabilidades como injeção de SQL e segredos codificados diretamente; o Microsoft Defender for DevOps integra-se ao GitHub para apresentar recomendações de segurança do Azure junto às alterações de código; e a verificação de vulnerabilidades do ACR Defender verifica as imagens de contêiner em busca de CVEs do OS e da camada da aplicação após cada envio. As descobertas de segurança aparecem como comentários nas solicitações de pull, para que sejam corrigidas antes da mesclagem.

Reunindo tudo

O fluxo de trabalho completo do desenvolvedor é um ciclo contínuo de feedback: um desenvolvedor faz commit do código, a CI compila e testa a imagem do contêiner, a imagem é enviada ao ACR com o SHA do commit como etiqueta, a CD implanta no ambiente de preparação e executa testes de fumaça, uma pessoa aprova a implantação em produção, o pipeline implanta em produção e cria uma anotação de versão, e o Application Insights monitora as taxas de erros, com reversão automática se os limites forem ultrapassados. A infraestrutura como código (Bicep ou Terraform) no mesmo repositório garante que o pipeline, o Container App e a configuração de monitoramento sejam todos controlados por versão junto com o código da aplicação.

Verificação rápida

Teste sua compreensão dos conceitos do Microsoft Azure Fundamentals (AZ-900) abordados nesta lição.

Recapitulação da lição

Nesta lição, você aprendeu que o fluxo de trabalho de desenvolvimento de ponta a ponta conecta o controle de código-fonte do GitHub, o CI/CD do GitHub Actions, o Azure Container Registry, o Container Apps e o Application Insights; as anotações de versão correlacionam implantações com alterações nas métricas para diagnosticar incidentes mais rapidamente; e a reversão automática baseada em consultas da taxa de erros reduz o raio de impacto de implantações problemáticas. A seguir, passaremos à preparação para o exame com uma revisão abrangente dos conceitos de nuvem e da arquitetura do Azure.

Perguntas Frequentes

A aula “Fluxo de trabalho do desenvolvedor de ponta a ponta” é grátis?

Sim — o texto completo de “Fluxo de trabalho do desenvolvedor de ponta a ponta” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Cloud & IT Cert Prep, atualize para CoddyKit PRO. O curso de Cloud & IT Cert Prep inclui 4 aulas no total.

O que vou aprender em “Fluxo de trabalho do desenvolvedor de ponta a ponta”?

Conecte o CI/CD do GitHub Actions, o Azure Container Registry, o Container Apps e o Application Insights em um ciclo interno completo do desenvolvedor, do commit à produção observável. Você pratica Cloud & IT Cert Prep com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Cloud & IT Cert Prep?

Nenhuma experiência prévia é necessária. Cloud & IT Cert Prep no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Fluxo de trabalho do desenvolvedor de ponta a ponta”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Cloud & IT Cert Prep?

Sim. Cada aula de Cloud & IT Cert Prep inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Identidade gerenciada para autenticação sem senha
  2. Azure Service Bus para mensagens desacopladas
  3. Azure Container Apps
  4. Fluxo de trabalho do desenvolvedor de ponta a ponta
← Voltar para Cloud & IT Cert Prep