Olá, pessoal! Meu nome é André Bessa e serei seu instrutor nesta jornada!
Audiodescrição: André se descreve como um homem negro, com barba e cabelos rente ao rosto. Veste uma camiseta azul-marinho com a logo da Alura na cor branca. Ao fundo, uma estante com itens decorativos iluminada por tons de azul e verde.
Para aproveitar ao máximo este curso, é altamente recomendável que você tenha concluído os cursos anteriores da formação. É importante ter conhecimentos em C#, orientação a objetos e testes automatizados. Também são essenciais os fundamentos de DevOps, especialmente em integração e entrega contínua.
Neste curso, você aprenderá a preparar nossa solução para ser entregue em um ambiente de homologação e produção. Isso pode incluir um ambiente de hospedagem personalizada ou plataformas de nuvem como Azure ou AWS.
Também vamos configurar o ambiente para tornar nossos testes de integração mais independentes, criar uma pipeline automatizada que incorpore os testes de unidade e de integração, e estabelecer um fluxo completo de integração e entrega contínua, utilizando ferramentas como GitHub Actions e Azure DevOps.
Continuaremos trabalhando com o projeto Jornada Milhas, que nos acompanha desde o início da formação. Neste curso, o objetivo é entregar a API do Jornada Milhas no Azure, para poder ser consumida por outras aplicações, incluindo testes automatizados no processo.
Para que você tenha uma visão geral do que vamos aprender, esquematizamos algumas etapas. Partiremos do ambiente local, desenvolveremos uma pipeline de CI (Integração Contínua) e CD (Entrega Contínua), e faremos a entrega da nossa API em um ambiente externo, no Azure.
Por que estudar e fazer este curso? Primeiramente, pela garantia da qualidade. É crucial que consigamos executar todos os testes antes de publicar nossa solução. Além disso, alinhamos nossas práticas às do mercado, onde a maioria das empresas implementa pipelines de integração e deploy (CI e CD), integrando os testes no processo. Isso também aumenta nossa produtividade, permitindo que você não precise interromper o desenvolvimento para fazer a entrega da solução em um ambiente externo ou para um cliente.
Além de tudo isso, convido você a aproveitar ao máximo nossa plataforma. Além dos vídeos, temos diversas atividades, um fórum bastante ativo e uma comunidade no Discord. Vamos nessa?
Te desejo as boas-vindas a mais um curso da Formação de Testes em .NET!
Neste curso, enfrentaremos o desafio de entregar nossa solução, a Jornada Milhas API, em um ambiente externo, como um ambiente de produção na nuvem, como Azure ou AWS. Para isso, precisamos gerar alguns arquivos para publicação.
Primeiro, em nosso projeto, podemos clicar com o botão direito do mouse em JornadaMilhas.API
, no Gerenciador de Soluções à direita, e selecionar "Publicar" para liberar os arquivos necessários para a implantação do projeto. No entanto, estamos focando bastante em testes, então o ideal é rodarmos os testes primeiro para garantir a qualidade do nosso projeto antes de gerar os arquivos para publicação.
Podemos executar todos os testes indo ao Gerenciador de Testes, à esquerda, e executar todos os testes. No entanto, esse processo ainda seria muito manual, pois precisaríamos primeiro executar os testes e depois publicar a API. Podemos melhorar esse fluxo automatizando essas etapas com um script.
Para isso, podemos adicionar um novo item ao nosso projeto, criando um arquivo de script (script.bat
). Nele, colocamos os comandos necessários para executar os testes e publicar a API, como dotnet test
para os testes de unidade e integração, e dotnet publish
para publicar a API.
dotnet test ./test/JornadaMilhas. Unit.Test
dotnet test ./test/JornadaMilhas.Integration.Test.API
dotnet publish ./src/JornadaMilhas.AΡΙ
Após salvar o script, abrimos um terminal e o executamos com .\script.bat
. No entanto, percebemos que o teste de integração não foi executado devido a uma dependência do Docker, que precisa estar em execução para que os testes de integração funcionem.
Vamos iniciar novamente os nossos contêineres e executar o script novamente. Ao fazer isso, ele deve rodar os testes de unidade, os testes de integração e, em seguida, gerar os arquivos para publicação.
Nosso objetivo é criar um processo menos dependente do ambiente local, onde possamos automatizar todas essas etapas: executar os testes, gerar o build e publicar a solução, garantindo que tudo esteja funcionando corretamente antes da implantação.
Essas etapas são conhecidas como pipeline. Vamos trabalhar com ferramentas que permitem criar pipelines automatizadas, que executam essas etapas de forma eficiente e confiável, culminando na implantação em um ambiente externo.
Uma dessas ferramentas que abordaremos é o GitHub Actions, que utilizaremos nas próximas aulas para configurar nossa pipeline automatizada.
Vamos iniciar a nossa jornada para automatizar esta pipeline utilizando o GitHub Actions. Já temos um script que define os passos a serem executados, e agora vamos adaptá-lo para o formato que o GitHub Actions utiliza.
Primeiro, vamos abrir o Visual Studio. Temos um script que realiza os testes de unidade, integração e API:
dotnet test ./test/JornadaMilhas. Unit.Test
dotnet test ./test/JornadaMilhas.Integration.Test.API
dotnet publish ./src/JornadaMilhas.AΡΙ
Precisamos criar um arquivo yml
dentro da pasta GitHub Actions
. Para isso, na pasta no gerenciador de arquivos, vamos copiar o arquivo script.bat
, que acabamos de criar, navegar até a pasta .github/workflows
e colar esse arquivo. Em seguida, vamos renomeá-lo para script.yml
a fim de reaproveitar a lógica.
Feito isso, voltamos ao Visual Studio e abrimos este arquivo script.yml
. Nele, vamos comentar as linhas do script original, pois esse não é o formato que o script.yml
utiliza no GitHub Actions. Para comentar, basta incluir #
no início de cada linha. Não vamos apagá-las para mantê-las como referência.
#dotnet test ./test/JornadaMilhas. Unit.Test
#dotnet test ./test/JornadaMilhas.Integration.Test.API
#dotnet publish ./src/JornadaMilhas.AΡΙ
Agora, vamos definir a pipeline no novo formato:
name: Pipeline
on:
push:
branches: ["main"]
jobs:
build:
name: Minha primeira pipeline
runs-on: ubuntu-latest
steps:
- name: Setup .NET
uses: actions/setup-dotnet@v2
with:
dotnet-version: 8.0.x
- name: Checkout do código
uses: actions/checkout@v2
Neste script, estamos especificando que vamos trabalhar com um repositório GitHub e utilizaremos a branch principal, main
.
No bloco jobs
, definimos o nome da pipeline como Minha primeira pipeline
. Em seguida, começamos a configuração do ambiente e das dependências. Vamos preparar um ambiente rodando em uma máquina Ubuntu, que é um sistema operacional Linux.
Na primeira etapa, configuramos a versão do .NET, que será a versão 8.0, e fazemos o checkout do código do repositório para execução da pipeline.
O próximo passo é começar a executar nossos comandos. Vamos inserir o name
no arquivo, criando uma nova etapa chamada Execução do teste de unidade
.
- name: Execução do teste de unidade
Um detalhe importante é que a formatação do yml
é bem específica; precisamos alinhar corretamente os espaços, caso contrário, o arquivo não será lido corretamente.
Em seguida, copiamos o comando dotnet test
, que deixamos salvo no início do código, usamos o comando run:
e colamos o trecho copiado.
- name: Execução do teste de unidade
run: dotnet test ./test/JornadaMilhas.Unit.Test
Assim, configuramos a primeira pipeline utilizando o arquivo yml
, definindo o ambiente e os comandos que serão executados. Por enquanto, vamos focar na execução dos testes de unidade, pois para os testes de integração precisaremos de outras configurações importantes.
Depois dos testes de unidade, queremos realizar a publicação da API. Vamos adicionar uma nova etapa com - name: Publicando a API
e, em seguida, o comando dotnet publish
da nossa API.
- name: Execução do teste de unidade
run: dotnet test ./test/JornadaMilhas.Unit.Test
- name: Publicando a API
run: dotnet publish ./src/JornadaMilhas.API
O código completo ficará assim:
#dotnet test ./test/JornadaMilhas. Unit.Test
#dotnet test ./test/JornadaMilhas.Integration.Test.API
#dotnet publish ./src/JornadaMilhas.AΡΙ
name: Pipeline
on:
push:
branches: ["main"]
jobs:
build:
name: Minha primeira pipeline
runs-on: ubuntu-latest
steps:
- name: Setup .NET
uses: actions/setup-dotnet@v2
with:
dotnet-version: 8.0.x
- name: Checkout do código
uses: actions/checkout@v2
- name: Execução do teste de unidade
run: dotnet test ./test/JornadaMilhas.Unit.Test
- name: Publicando a API
run: dotnet publish ./src/JornadaMilhas.API
Agora, vamos salvar o arquivo. Lembrando que, neste exemplo didático, criamos um script e depois o renomeamos para um arquivo yml
para ajustar e criar nossa pipeline no GitHub Actions. No dia a dia, você pode começar diretamente no arquivo yml
.
Com o arquivo criado, o próximo passo é executar a nossa pipeline e validar se os testes são executados corretamente e se a publicação da API ocorre de forma automatizada. Isso será feito no momento em que fizermos um push para a branch main
. Vamos seguir com essa etapa logo na sequência.
O curso Testes em .NET: integre seus testes nos pipelines de CI/CD possui 76 minutos de vídeos, em um total de 53 atividades. Gostou? Conheça nossos outros cursos de .NET em Programação, ou leia nossos artigos de Programação.
Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:
Impulsione a sua carreira com os melhores cursos e faça parte da maior comunidade tech.
1 ano de Alura
Assine o PLUS e garanta:
Formações com mais de 1500 cursos atualizados e novos lançamentos semanais, em Programação, Inteligência Artificial, Front-end, UX & Design, Data Science, Mobile, DevOps e Inovação & Gestão.
A cada curso ou formação concluído, um novo certificado para turbinar seu currículo e LinkedIn.
No Discord, você tem acesso a eventos exclusivos, grupos de estudos e mentorias com especialistas de diferentes áreas.
Faça parte da maior comunidade Dev do país e crie conexões com mais de 120 mil pessoas no Discord.
Acesso ilimitado ao catálogo de Imersões da Alura para praticar conhecimentos em diferentes áreas.
Explore um universo de possibilidades na palma da sua mão. Baixe as aulas para assistir offline, onde e quando quiser.
Acelere o seu aprendizado com a IA da Alura e prepare-se para o mercado internacional.
1 ano de Alura
Todos os benefícios do PLUS e mais vantagens exclusivas:
Luri é nossa inteligência artificial que tira dúvidas, dá exemplos práticos, corrige exercícios e ajuda a mergulhar ainda mais durante as aulas. Você pode conversar com a Luri até 100 mensagens por semana.
Aprenda um novo idioma e expanda seus horizontes profissionais. Cursos de Inglês, Espanhol e Inglês para Devs, 100% focado em tecnologia.
Transforme a sua jornada com benefícios exclusivos e evolua ainda mais na sua carreira.
1 ano de Alura
Todos os benefícios do PRO e mais vantagens exclusivas:
Mensagens ilimitadas para estudar com a Luri, a IA da Alura, disponível 24hs para tirar suas dúvidas, dar exemplos práticos, corrigir exercícios e impulsionar seus estudos.
Envie imagens para a Luri e ela te ajuda a solucionar problemas, identificar erros, esclarecer gráficos, analisar design e muito mais.
Escolha os ebooks da Casa do Código, a editora da Alura, que apoiarão a sua jornada de aprendizado para sempre.