Azure DevOps Tutorial: Criar, testar e implantar aplicativos

Configurando seu ambiente de DevOps do Azure

Para acessar o ambiente do Azure DevOps, você deve primeiro configurar tudo para promover a colaboração da equipe e o processo de desenvolvimento de ponta a ponta.

Criando uma conta do Azure DevOps

Você precisará criar uma conta antes de usar o Azure DevOps. Veja como você pode começar:

• Visite o site do Azure DevOps: Vá para o Azure DevOps para começar o processo de registro. Clique em . Comece a usar o Azure.

• Entre com sua conta da Microsoft: Se você já tiver uma conta da Microsoft (por exemplo, Outlook, Xbox, Office 365), poderá usá-la para entrar. Caso contrário, você precisará criar uma conta gratuita da Microsoft.
• Clique em Entrar ou Crie um! (Inscreva-se).
• Use suas credenciais da Microsoft ou outras opções de login para fazer login.
• Clique em Em seguida.

• Inicie o processo de configuração: Clique na caixa de seleção e continue. Você será solicitado a criar uma nova organização depois de fazer login. Suas equipes e projetos de DevOps do Azure ficarão hospedados nessa organização. 

Criando uma organização no Azure DevOps

Uma organização no Azure DevOps é onde todos os seus projetos e repositórios residem. É aqui também que você gerencia suas equipes, permissões e faturamento.

• Dê um nome à sua organização: Escolha um nome exclusivo para sua organização. Isso é importante porque ele aparecerá como parte do URL do Azure DevOps (por exemplo, https://dev.azure.com/yourorganization ).
• Escolha sua região: O Azure DevOps requer a seleção de uma região onde seus dados serão armazenados. A região padrão deve funcionar para a maioria, mas se você tiver requisitos específicos, como reclamações, poderá escolher outra região mais próxima da sua base de usuários (por exemplo, os Estados Unidos).
• Confirme e continue: Depois de preencher esses detalhes, clique em Continue. Sua organização está pronta para começar, e você será direcionado para o portal principal do Azure DevOps!

Explorando a interface do Azure DevOps

Depois de criar sua organização, você será levado ao portal do Azure DevOps. As principais seções dos serviços são Overview (Visão geral), Boards (Quadros), Repos, Pipelines, Test Plans (Planos de teste) e Artifacts (Artefatos).

Essa interface de usuário pode parecer esmagadora no início, mas as principais funções do Azure DevOps podem ser resumidas em controle de versão, CI/CD e gerenciamento de projetos.

Criando um novo projeto

Agora que sua conta e organização estão configuradas, vamos criar seu primeiro projeto para o Azure DevOps.

Configuração de um novo projeto

• Clique em "New Project" (Novo projeto): No portal do Azure DevOps, clique no botãoNovo projeto. Isso permitirá que você configure seu primeiro projeto.
• Preencha os detalhes do projeto:
• Nome do projeto: Escolha um nome para o seu projeto (por exemplo, "yourproject").
• Descrição (opcional): Descreva brevemente do que se trata este projeto.
• Visibilidade: Escolha se você deseja que seu projeto seja público ou privado. Qualquer pessoa pode visualizar projetos públicos, o que o torna uma excelente opção para projetos de código aberto. Os projetos privados são protegidos e só podem ser acessados por aqueles que você convidar para o projeto.
• Crie o projeto: Depois de inserir os detalhes do projeto e selecionar o sistema de controle de versão, clique em Criar projeto. Agora, seu projeto está configurado e pronto para ser executado!

• Sistema de controle de versão: O Azure DevOps oferece dois tipos de sistemas de controle de versão: Git e Team Foundation Version Control (TFVC).
• O Git é um sistema de controle de versão distribuído que é mais moderno e amplamente utilizado na comunidade de desenvolvedores. É a melhor opção para a maioria dos projetos.
• O TFVC é um sistema de controle de versão centralizado, mas é menos comum e geralmente usado em projetos legados.

Em minha experiência, eu o aconselharia a escolher a Git se você estiver apenas começando ou não tiver um motivo específico para escolher a TFVC.

Você está pronto para assumir o controle do seucódigo? Aprenda Git ecomece a gerenciar seus projetos como um profissional.

Usando o Azure Repos para controle de versão

Agora que você já tem seu projeto pronto, vamos analisá-lo a fundo e explorar alguns de seus principais recursos.

Configuração de um repositório Git

• Navegue até Repos: No menu à esquerda, selecione a guiaRepos. Você gerenciará seu código aqui.

• Clone o repositório: Você pode clonar o repositório no seu computador local usando a URL na seção Repositórios, por exemplo.

# This command clones the specified Git repository from Azure DevOps to your local machine.
git clone https://yourorganization@dev.azure.com/yourorganization/yourproject/_git/yourrepo

Vamos dividir o comando acima em partes:

• Substitua yourorganization pelo nome de sua organização.
• Substitua yourproject pelo nome do seu projeto.
• Substitua yourrepo pelo nome do seu repositório.

Abaixo está o URL na minha seção Repos:

• Envie seu código: Depois que seu repositório for clonado localmente, você poderá adicionar seu código e enviá-lo de volta ao Azure DevOps.

git add .
git commit -m "my first commit"
git push origin main

Parabéns! Você acabou de fazer sua primeira confirmação no Azure Repos.

Ramificação e mesclagem

No desenvolvimento de software, a ramificação permite que você trabalhe em recursos ou correções separadamente do projeto principal. Mesclar é o processo de trazer as alterações de uma ramificação para outra.

• Crie uma ramificação localmente: Para começar a trabalhar em um recurso, crie uma nova ramificação: 

git checkout -b feature-branch

• Envie a ramificação para o Azure DevOps: Depois de fazer alterações em sua nova ramificação, envie-a para o Azure DevOps:

git push origin feature-branch

Alternância entre filiais

Para alternar entre as ramificações, use o seguinte comando:

git checkout main

Ou para mudar para uma filial diferente:

git checkout feature-branch

Exclusão de um ramo

Depois que um recurso é mesclado, você pode excluir o ramo local e remotamente:

• Para excluir a filial local: 

git branch -d feature-branch

• Para excluir o ramo remoto:

git push origin --delete feature-branch

Mesclar ramificações por meio de pull requests

• Crie uma solicitação pull: Quando a ramificação do recurso estiver configurada para ser mesclada com a ramificação principal, vá para a seção Pull Requests no Azure DevOps e clique em New Pull Request.

• Revisar e mesclar: Revise as alterações e clique em Complete para mesclar as alterações no branch principal.
• Resolver conflitos: Se houver algum conflito de mesclagem (ou seja, alterações na mesma parte do código), você precisará resolvê-lo manualmente. O Azure DevOps ajudará a orientar você nesse processo, destacando as áreas conflitantes.

Gerenciar solicitações pull

As solicitações pull são essenciais para a revisão e a colaboração do código. Eles permitem que os membros da equipe revisem o código antes que ele seja mesclado ao ramo principal.

Criando um pull request

• Crie a solicitação pull: Depois de fazer o push da ramificação do recurso, navegue até Pull Requests e clique em New Pull Request. Escolha o ramo de origem (por exemplo, feature-branch ) e o ramo de destino (por exemplo, main ).
• Descreva o pull request: Forneça uma descrição clara de quais alterações estão incluídas no pull request. Isso ajuda os revisores a entenderem o que devem procurar.

Revisão e aprovação de solicitações pull

• Solicite avaliações: Adicione revisores da sua equipe que revisarão as alterações de código.
• Aprovar e fundir: Quando a pull request for aprovada, clique em Concluir para fazer o merge no branch principal.

Criação e gerenciamento de pipelines de CI/CD

O Azure DevOps também inclui Pipelines para automatizar o processo de criação, teste e implantação.

O que é um pipeline no Azure DevOps?

Um pipeline no Azure DevOps é uma coleção de processos automatizados que ajudam você:

• Crie seu código (pipeline de criação)
• Teste-o
• Implemente-o em diferentes ambientes (pipeline de lançamento)

Esses pipelines garantem que seu código esteja sempre pronto para implantação e possa ser testado automaticamente.

Criando um pipeline de compilação

• Navegue até Pipelines: Em seu projeto do Azure DevOps, clique em Novo pipeline na seção Pipelines seção.

• Escolha uma fonte: Selecione Repositórios do Azure Git como a fonte e escolha seu repositório.

• Configure o pipeline: Você pode configurar o pipeline usando o editor YAML ou o editor Classic. Vamos usar o YAML, uma forma baseada em código de definir o pipeline.

Vamos usar um aplicativo Node.js básico como exemplo. Nosso arquivo azure-pipelines.yml abaixo contém o código YAML que o Azure DevOps criou automaticamente .

# Node.js
# Build a general Node.js project with npm.
# Add steps that analyze code, save build artifacts, deploy, and more:
# https://docs.microsoft.com/azure/devops/pipelines/languages/javascript

trigger:
- main

pool:
  vmImage: ubuntu-latest

steps:
- task: NodeTool@0
  inputs:
    versionSpec: '20.x'
  displayName: 'Install Node.js'

- script: |
    npm install
    npm run build
  displayName: 'npm install and build'

• Salve e execute: Salve o pipeline e execute-o para ver se tudo funciona corretamente.

Executando o pipeline de compilação

Depois que o pipeline de compilação estiver configurado, você poderá executá-lo manualmente clicando em Run Pipeline. O pipeline passará por diferentes estágios, como "instalar dependências", "executar testes" e "construir".

Você pode verificar os logs de cada etapa para solucionar problemas de compilações com falha. O Azure DevOps fornece logs detalhados para ajudar você a determinar o que deu errado.

Configuração da implantação contínua (CD)

• Navegue até Releases: Na seção Pipelines, clique em Releases e, em seguida, em New Pipeline.

• Adicione um artefato: Vincule o artefato do seu pipeline de compilação como a origem do pipeline de liberação.

• Implantar em ambientes: Configure ambientes como Staging e Production onde você deseja que seu aplicativo seja implantado.

Automatize as implementações

O Azure DevOps pode implantar automaticamente seu aplicativo sempre que uma nova compilação for acionada. Você pode configurar isso adicionando acionadores e definindo tarefas para implementar em plataformas como Azure, AWS, etc.

Gerenciando itens de trabalho com o Azure Boards

O Azure Boards é o coração do gerenciamento de projetos no Azure DevOps. Ele ajuda as equipes a planejar, acompanhar e discutir o trabalho em todo o ciclo de vida do desenvolvimento de software por meio de recursos como tarefas, bugs, histórias de usuários e épicos. 

Seja seguindo o Scrum ou o Kanban, o Azure Boards permite que você visualize, priorize e gerencie seu trabalho com eficiência.

Vamos detalhá-lo passo a passo.

Criar e gerenciar itens de trabalho

O Azure Boards permite que você gerencie tarefas, bugs e recursos usando itens de trabalho.

• Crie um item de trabalho: Vá para Boards, selecione Work items e clique em New Work Item.

Você pode criar:

• Épico: Um projeto grande ou um trabalho extenso que abrange várias partes menores.
• Questão: Um problema ou bug específico que precisa ser corrigido.
• Tarefa: Um trabalho único e acionável a ser feito.

• Vamos selecionar Epic. 
• Insira o título, a descrição, a prioridade, a data de início e a data de destino. Clique em Salvar.

• Atribuir itens de trabalho
• Abra o item de trabalho que você acabou de criar. 
• No campo Atribuir pessoas, selecione um membro da equipe. 
• Selecione Adicionar tag para melhor categorização. Clique em Salvar.

• Programa de progresso
• Use o campo Estado para atualizar o status (por exemplo, Novo, Ativo, Resolvido, Fechado). 
• Adicione comentários ou anexos para fornecer atualizações ou contexto.

Em minha experiência, as equipes permanecem responsáveis e concentradas quando são designados proprietários claros e prazos razoáveis são especificados.

Configuração de sprints e backlogs

Sprints e backlogs ágeis são essenciais para o desenvolvimento iterativo. Veja como você pode configurá-los:

• Criar Sprints: Sprints são iterações de trabalho com prazo determinado. Você pode configurar sprints acessando Boards > Sprints e adicionando novos sprints (por exemplo, "Sprint 1").

• Clique em Configure Team Settings ( Configurar configurações da equipe ) e defina a duração do sprint (por exemplo, 2 semanas).

• Adicione datas de início e término para o sprint.

• Gerencie os backlogs do produto: Na visualização Backlog, você pode organizar seus itens de trabalho em prioridades. Navegue até Quadros > Atrasos. 

• Arraste e solte itens de trabalho no backlog para priorizá-los. 

• Visualize o progresso: O Azure DevOps ajuda você a visualizar os itens de trabalho e movê-los pelos estágios (por exemplo, To Do, Doing, Done). Use a visualização de quadro para ver os itens de trabalho em colunas. 

• Personalize as colunas de acordo com o fluxo de trabalho da sua equipe.

Na minha experiência, seguir esse procedimento reduz o tempo de inatividade e a confusão da sua equipe se o seu backlog estiver bem organizado e claro sobre o que precisa ser feito em seguida.

Vinculação de itens de trabalho a commits

Ao vincular itens de trabalho a commits, você ajuda a rastrear as alterações de código para cada tarefa ou bug. Veja como:

• Link para um commit: Isso pode ser feito de duas maneiras: por meio do console do Azure DevOps ou do seu ambiente de desenvolvimento local.
• Console do Azure DevOps: Em sua mensagem de confirmação do Git, inclua o endereço #WorkItemID (por exemplo, #1). Clique em Commit. O Azure DevOps vincula automaticamente o commit ao item de trabalho.

• Ambiente de desenvolvimento local:
• Em seu ambiente de desenvolvimento local, abra o terminal ou o prompt de comando. Faça suas alterações no código e prepare-se para confirmá-las.
• Na mensagem de confirmação, inclua o ID do item de trabalho com uma hashtag (por exemplo, Fixed bug in login analytics #1).
• Conclua o commit executando o comando apropriado:

git commit -m "Fixed bug in login analytics #1"

• Envie o commit para o repositório remoto (Azure Repo):

git push origin feature-branch

• Link para uma solicitação pull:
  • Ao criar uma pull request, mencione o ID do item de trabalho no campo Descrição.
  • Clique em Create. O Azure DevOps vinculará automaticamente o pull request ao item de trabalho.

Em minha experiência, essa vinculação fornece rastreabilidade total, facilitando a visualização de quais alterações de código abordaram tarefas ou bugs específicos. Lembre-se de que você pode ver os commits e PRs vinculados na seção Development do item de trabalho.

Integração com outras ferramentas

O Azure DevOps se destaca quando integrado a outras ferramentas, como o GitHub e as plataformas de nuvem. Vamos explorar como você pode configurar isso.

Integrando o Azure DevOps com o GitHub

Ao conectar o Azure DevOps ao GitHub, você otimiza a colaboração e a automação de CI/CD. Veja como: 

• Conecte o GitHub ao Azure Pipelines: 
• Ir para Pipelines > Criar Pipeline.

• Selecionar GitHub como a fonte.

• Autorize o Azure DevOps a acessar seus repositórios do GitHub.

Você é novo no GitHub? Descubra como você pode colaborar, rastrear alterações e contribuir para projetos de código aberto com o curso de conceitos do GitHub. curso de conceitos do GitHub.

• Configurar um pipeline 
  • Escolha um repositório e configure seu arquivo de pipeline YAML. 

• Defina as etapas de compilação e implantação. Exemplo de YAML:

# Set up the trigger for the pipeline
trigger:  
  # Specify the branches to include
  branches:  
    include:  
      # Include the main branch
      - main  

# Define the jobs for the pipeline
jobs:  
  # Create a job named 'Build'
  - job: Build  
    # List the steps for the 'Build' job
    steps:  
      # Add a script step to print a message
      - script: echo "Building the project..." 

Em minha experiência, essa integração garante automaticamente atualizações e implementações de código sem interrupções, reduzindo o esforço manual.

Conectando o Azure DevOps ao Azure e a outras plataformas de nuvem

O Azure DevOps se integra nativamente aos serviços do Azure, como o Azure Web Apps, o Azure Kubernetes Services (AKS) e muitos outros. Vamos aprender como conectar nosso Azure DevOps ao Azure Web Apps.

• Link para os serviços do Azure:
  • Na parte inferior esquerda do seu projeto, vá para Project Settings (Configurações do projeto ) e clique em Service Connections (Conexões de serviço ) na seção Pipelines. 

• • Clique em Nova conexão de serviço e escolha Azure Resource Manager. 

• • Faça a autenticação com sua conta do Azure.
• Implantar no Azure 
  • Volte para os pipelines e configure o pipeline.
  • Em seu pipeline, adicione uma tarefa para implantar no Azure. 
  • Especifique o grupo de recursos e os detalhes do serviço. Exemplo de tarefa YAML:

# Define the task for deploying to an Azure Web App
- task: AzureWebApp@1  
  inputs:  
    # Specify your Azure subscription service connection
    azureSubscription: 'Your-Service-Connection'  
    # Specify the name of your web app
    appName: 'Your-Web-App' 

Vamos dividir o comando acima em partes: 

• Substitua Your-Service-Connection pelo nome da conexão de serviço com acesso à sua assinatura do Azure.
• Substitua Your-Web-App pelo nome real do seu aplicativo Web no Azure.

Na minha experiência, essa conexão facilita as implementações, permitindo que você se concentre principalmente na criação de um software excelente.

Monitoramento e geração de relatórios no Azure DevOps

O monitoramento e a geração de relatórios são processos fundamentais para manter a integridade do seu projeto no Azure DevOps. Vamos explorar como você pode fazer isso de forma eficaz.

Visualização das métricas do pipeline

As métricas de pipeline esclarecem o desempenho de compilações e implementações. É assim que você pode chegar até eles.

• Monitorar a integridade do pipeline 
  • Ir para Pipelines > Analytics.
  • Visualize métricas como taxa de aprovação do pipeline, taxa de aprovação do teste e duração do pipeline.

• Identificar gargalos 
  • Para encontrar estágios de falha e compilações lentas, use o Execuções do pipeline do pipeline.

• • Navegue até as configurações da organização do Azure DevOps Configurações da organização > Pipelines > Trabalhos paralelos para usar trabalhos paralelos para melhorar o desempenho e otimizar as tarefas.

Em minha experiência, o armazenamento em cache das dependências, a divisão dos trabalhos e a otimização da estrutura do pipeline podem reduzir significativamente os tempos de compilação e as taxas de falha.

Usando os relatórios do Azure DevOps

O Azure DevOps oferece ferramentas robustas de geração de relatórios para que você acompanhe a produtividade da equipe e o progresso do projeto.

• Relatórios de acesso 
  • Ir para Análise > Relatórios.
  • Escolha entre relatórios pré-criados, como Diagrama de Fluxo Cumulativo, Velocidade ou Burndown.

• Personalizar relatórios 
  • Use o Power BI para criar painéis personalizados. Para fazer isso, use o Conector de dados do Power BI,acesse o Power BI Online e faça loginna sua conta.
  • Clique no botão Início no canto superior esquerdo e, em seguida, selecione Obter dados na faixa de opções.
  • Você verá uma lista de fontes de dados na janelaGet Data. Selecione Online Services > Azure DevOps (somente Quadros) como seu conector de dados.

• Insira os detalhes da sua conta, como organização e Projeto da equipe para sincronizar seus dados.

• Exportar dados para análise posterior.

Na minha experiência, você pode tomar decisões orientadas por dados com esses relatórios analíticos, que oferecem insights práticos.

Práticas recomendadas para DevOps do Azure

Agora que você aprendeu sobre os principais serviços do Azure DevOps e muitos outros, vamos ver como tirar o máximo proveito do Azure DevOps seguindo essas práticas recomendadas.

Práticas recomendadas de controle de versão

• Use estratégias de filiais 
• Adotando o Git Flow ou o GitHub Flow para ramificação. 
• Sempre mantenha a ramificação main estável e use as ramificações de recursos para desenvolvimento.
• Escreva mensagens de compromisso claras 
• Use o formato: type(scope): description (por exemplo, feat(login): add user authentication ).
• Revisar solicitações pull 
• Exigir pelo menos um revisor antes de mesclar suas solicitações pull. 
• Use os comentários para sugerir melhorias.

Uma base de código limpa e reutilizável resulta de boas práticas de controle de versão.

Otimização de pipelines

• Usar dependências de cache: A repetição do download das mesmas dependências pode fazer com que você perca muito tempo trabalhando com gerenciadores de pacotes. O Azure DevOps oferece suporte a mecanismos de armazenamento em cache, como a tarefa Cache, que permite que você armazene em cache as dependências entre as execuções do pipeline. 

Exemplo de tarefa de cache YAML:

# Define the cache task
- task: Cache@2  
  inputs:  
    # Set the cache key using npm, the OS, and package-lock.json
    key: 'npm | "$(Agent.OS)" | package-lock.json'  
    # Specify the path to the node_modules directory
    path: 'node_modules'

• Trabalhos divididos: Divida trabalhos gigantescos em tarefas menores e paralelas. Considere uma carga de trabalho enorme que exige muito tempo para ser concluída. Ao dividi-lo em tarefas separadas, você pode executá-lo simultaneamente, o que acelera a operação como um todo.

Exemplo de trabalhos YAML:

jobs:
  # Define the first build job
  - job: BuildJob1
    displayName: 'Build Job 1'
    pool:
      vmImage: 'ubuntu-latest'
    steps:
      # Add a script step to print a message for Building Project A
      - script: echo "Building Project A"
        displayName: 'Build Project A'

  # Define the second build job
  - job: BuildJob2
    displayName: 'Build Job 2'
    pool:
      vmImage: 'ubuntu-latest'
    steps:
      # Add a script step to print a message for Building Project B
      - script: echo "Building Project B"
        displayName: 'Build Project B'

  # Define the test job
  - job: TestJob
    displayName: 'Run Tests'
    # Specify that this job depends on the completion of BuildJob1 and BuildJob2
    dependsOn: 
      - BuildJob1
      - BuildJob2
    pool:
      vmImage: 'ubuntu-latest'
    steps:
      # Add a script step to print a message for Running Tests
      - script: echo "Running Tests"
        displayName: 'Run Tests'

• Use modelos: Crie modelos de pipeline reutilizáveis para tarefas cotidianas. Ao fazer isso, você não precisa reescrever o mesmo código repetidamente. Vamos criar um modelo simples para uma tarefa de compilação:

Exemplo de modelo YAML:

# Define parameters for the pipeline
parameters:
  # Specify a parameter for the build configuration
  - name: buildConfiguration
    type: string
    default: 'Release'

# List the steps for the pipeline
steps:
  # Add a task to run the .NET Core CLI
  - task: DotNetCoreCLI@2
    inputs:
      # Set the command to 'build'
      command: 'build'
      # Pass the build configuration as an argument
      arguments: '--configuration $(buildConfiguration)'

Descobri que a otimização do pipeline resulta consistentemente em economia de tempo e recursos.

Gerenciar segredos e segurança

• Use o Azure Key Vault: Armazene informações confidenciais, como chaves de API, no Azure Key Vault. Para fazer isso, acesse o Portal do Azure, crie um novo Key Vault e adicione seus segredos (por exemplo, chaves de API).

• Volte para o Azure DevOps e crie uma conexão de serviço com sua assinatura do Azure para que seu pipeline possa acessar o Key Vault.

• Vá para Pipelines > Biblioteca no Azure DevOps e crie um novo grupo de variáveis. 

• Vincule o grupo de variáveis ao Key Vault para que você obtenha automaticamente os segredos.
• Faça referência a segredos em seus pipelines usando grupos de variáveis. Exemplo de YAML:

# azure-pipelines.yml
trigger:
- main

variables:
- group: my-variable-group  # Reference the variable group that links to the Key Vault

jobs:
- job: BuildJob
  pool:
    vmImage: 'ubuntu-latest'
  steps:
  - script: echo "Using secret from Key Vault."
    env:
      MY_API_KEY: $(my-secret)  # Reference the secret from the variable group
    displayName: 'Print Secret'

Com base no exemplo acima: É feita referência ao grupo de variáveis my-variable-group, que contém segredos do Key Vault. A etapa do script ecoa uma mensagem, usando o segredo do grupo de variáveis $(my-secret) como uma variável de ambiente.

• Restringir permissões 
  • Lembre-se sempre de limitar o acesso a pipelines e repositórios com base nas funções.

Uma prática essencial no desenvolvimento moderno de software é a segurança. A segurança não é negociável e não pode ser comprometida devido às consequências em jogo. 

Conclusão

Este tutorial nos ensinou a configurar um ambiente do Azure DevOps, usar o Azure Repos para controle de versão, criar e gerenciar pipelines de CI/CD, rastrear e gerenciar itens de trabalho com o Azure Boards, integrar o Azure DevOps a outras ferramentas, práticas recomendadas para o Azure DevOps e muito mais.

A consistência é o segredo do sucesso. Revise seus processos com frequência, obtenha feedback e faça ajustes. Dominar esses recursos pode liberar todo o seu potencial como profissional de dados no desenvolvimento de software. Explore o Azure DevOps, experimente essas ferramentas e veja como sua equipe é muito mais produtiva.

Para se aprofundar no Microsoft Azure, confira os cursos a seguir: 

• Entendendo o Microsoft Azure - Crie uma base sólida no Microsoft Azure e libere o poder da computação em nuvem.
• Microsoft Azure Fundamentals (AZ-900) - Prepare-se para o exame com este programa para iniciantes que abrange todos os principais fundamentos do Azure.
• Noções básicas sobre a arquitetura e os serviços do Microsoft Azure - Saiba como a arquitetura e os serviços do Azure trabalham juntos para potencializar as soluções em nuvem.