Continuous Delivery for Machine Learning: completando o Pipeline

Configurando a aplicação - Apresentação

Tudo bem, pessoal? Boas-vindas a mais um curso da Alura! Sou Guilherme Silveira e serei seu instrutor neste curso sobre Entrega Contínua para Machine Learning.

Autodescrição: Guilherme é uma pessoa branca, de cabelos curtos, escuros e ondulados e olhos castanhos. Está de camiseta amarela. Ao fundo, há uma parede com linhas verticais e horizontais formando uma grade, um quadro, uma luminária com a luz amarela acesa, duas prateleiras pequenas com enfeites e um vaso de planta.

Esse é um assunto muito legal e que toca a minha vida de diversas formas. A entrega contínua foi uma aventura da minha fase mais jovem que me acompanha até hoje, na parte de desenvolvimento de software e de Machine Learning.

Neste curso, o nosso foco não é escrever um projeto de Machine Learning. Temos outros cursos na Alura que podem te ensinar a escrever o código e a treinar o modelo.

Aqui, pegaremos um sistema existente e verificaremos todo o processo de build. Se fizermos uma alteração no nosso código, como fazemos para que tudo funcione?

São várias fases: precisamos ter certeza de que tudo está funcionando por meio de testes de unidade, verificar o score mínimo de qualidade que deve ser atingido, colocar o modelo em produção,

Se você quiser rodar um experimento e orquestrá-lo com o pipeline, é possível fazer isso por meio do build. Existem muitas possibilidades, pois a construção passa a ser um processo de código, em que temos total liberdade de customização, seja para rodar testes automatizados, para rodar valores ou para adaptar o projeto conforme os desejos de quem roda o build.

Após a produção do build, precisamos ter certeza de que ele está rodando da maneira que gostaríamos. Por isso, precisamos ter a capacidade de monitorar a utilização e observar os resultados dos algoritmos de Machine Learning para retroalimentar o treino e o processo.

O foco deste curso é trabalhar com um projeto baseado em um projeto da ThoughtWorks, nossa parceira neste curso. Utilizaremos diversas ferramentas para isso.

Nosso objetivo não é aprofundar os nossos conhecimentos nas ferramentas, mas visualizar o pipeline de um projeto de Machine Learning com continuous deployment, continuous delivery e continuous integration.

Te vejo daqui a pouco!

Configurando a aplicação - Docker

O nosso curso se baseia em um projeto de aprendizado de máquina (Machine Learning). É natural que queiramos rodar os nossos projetos, seja na nossa máquina, em produção ou onde quer que seja. Por isso, utilizaremos um projeto existente ao longo deste curso.

Aí, você pode dizer: "Guilherme, mas eu queria aprender a desenvolver o código!". Se este é o seu caso, temos outros cursos aqui na Alura para isso, mas a nossa ideia aqui é pegar um modelo existente escrito por outra pessoa ou por nós mesmos e colocá-lo em produção.

Em seguida, queremos verificar como ele funciona. Queremos rodar experimentos e alterar parâmetros para ver tudo fluindo. Este é o foco deste curso.

O projeto do curso

Primeiro, precisamos do código! Nas atividades deste curso, teremos o link com um projeto para vocês acompanharem o curso. Eu abri o projeto no meu GitHub, mas quero que você copie e cole este projeto para editá-lo em casa, fazendo a sua própria versão dele.

Para fazer isso, vocês clicarão no botão "Fork", localizado na lateral superior direita do GitHub. Com ele, vocês conseguirão criar variações desse projeto no GitHub de vocês.

Se você ainda não tem uma conta no GitHub, precisará criar uma, fazer o login e só então clicar em "Fork". Após clicar, seremos redirecionados para outra janela que perguntará se queremos mudar o nome do repositório, a descrição e outras informações. Podemos deixar tudo conforme as configurações padrão e clicar em "Create fork".

Criado o Fork, você será redirecionado para a página do seu projeto, com uma cópia que tem absolutamente tudo o que o meu projeto tinha.

Agora, precisamos baixar o projeto no nosso computador. Para fazer isso, clicaremos no botão "Code", no canto superior direito da página. Existem várias formas de fazer o download.

Para quem já usa o GitHub, é possível copiar o link HTTPS e usá-lo no seu sistema. Para quem nunca trabalhou com o GitHub, é possível clicar "Open with GitHub Desktop" (Abrir com GitHub Desktop). Para isso, é preciso ter o GitHub Desktop instalado no computador.

Usando o GitHub Desktop

Com uma busca no Google usando as palavras "GitHub Desktop", você encontrará o site do GitHub Desktop e poderá baixá-lo. Após concluída a instalação, já podemos clicar em "Open with GitHub Desktop".

Após clicar no botão, o GitHub Desktop abrirá com uma janela intitulada "Clone a repository". Nela, aparecerá o diretório onde o projeto será armazenado. Em seguida, clicamos em "Clone". Uma barra de progresso aparecerá indicando a clonagem do projeto para o computador.

Ao terminar, surge uma outra janela perguntando como você pretende trabalhar com o projeto clonado. As duas opções disponíveis são: fazer alterações e contribuir para o projeto original ou fazer modificações apenas para você.

Selecionaremos a segunda opção ("For my own purposes") e clicaremos em "Continuar" ("Continue"). Esses passos são destinados ao GitHub Desktop, mas fique à vontade para usar a ferramenta de sua preferência.

Se você voltar ao GitHub, verá que o projeto original foi "forkado" de um projeto da ThoughtWorks, com quem este curso foi criado.

Usando o Visual Studio

Agora que o projeto já está na minha máquina, vou usar uma IDE específica, o Visual Studio, que pode ser baixado no site www.visualstudio.com.

Após o download, abra o programa. Ele abrirá uma tela de boas-vindas. O próximo passo é clicar em "File" (Arquivo) e "Open Folder…" (Abrir um diretório). Em seguida, escolha a pasta onde você baixou todo o projeto.

Na barra lateral esquerda chamada "Explorer" (Explorador), você poderá abrir os arquivos do projeto. Agora que o projeto está na máquina, queremos rodá-lo.

Mas, calma: um projeto de aprendizado de máquina costuma ter vários componentes, especialmente neste curso. Alguns deles são:

• O modelo matemático e computacional do aprendizado de máquina;
• Um servidor web;
• Um banco de dados;
• Um controle de versão do modelo;
• Um sistema de logs;
• … e assim por diante.

São vários os componentes da arquitetura composta pelas máquinas e pelos sistemas que dialogam entre si. Imagine a quantidade de comandos para levantar tudo isso. Sem falar essa arquitetura seja complexa. Isso seria difícil de reproduzir.

Usando o Docker

Porém, existe uma ferramenta que revolucionou o mercado de entrega de arquitetura: o Docker. Com o Docker, podemos indicar, por exemplo, que desejamos rodar um servidor Apache HTTP em duas máquinas para servir arquivos específicos. O Docker permite uma série de personalizações.

Isso faz com que, com apenas um comando, consigamos levantar uma máquina. O Docker cria uma espécie de "máquina virtual". É como se ele virtualizasse uma máquina dentro do nosso computador, sem a necessidade de instalar nada.

O Docker resolve problemas de incompatibilidade por meio de arquivos pelos quais indicamos as ações a serem executadas. No nosso projeto, um destes arquivos é o Dockerfile-jenkins.

Na primeira linha deste arquivo, encontramos o seguinte código:

FROM jenkins/jenkins:2.347-jdk11

Com isso, ele está sendo orientado a pegar a imagem, ou seja, o arquivo compactado (zip) de uma máquina, pois utilizaremos uma máquina similar. Assim, vários comandos são executados no jenkins.

Toda vez que solicitarmos um jenkins (falaremos mais adiante sobre o que é um jenkins), o arquivo compactado da máquina será baixado pelo Docker, descompactado de forma inteligente no seu computador e executar os comandos descritos no código. Desse modo, temos o jenkins rodando no nosso computador sem precisarmos nos preocupar com instalação.

Para instalar o Docker, você pode buscar "install docker" no Google. Serão oferecidas opções para instalação no Windows, Ubuntu e Mac. O Windows é o mais trabalhoso dos três, pois tem um passo extra. Sugiro que você faça o download do Docker Desktop e instale esta versão.

Essa opção é a melhor porque a nossa arquitetura para rodar o aprendizado de máquina envolverá banco de dados, log, busca em log, escrita em log, simulação de API da Amazon, sistema web, sistema de desenvolvimento e o processo de build. Assim, existe uma série de "máquinas virtuais" que rodam na nossa máquina.

No meu caso, após instalar o Docker Desktop no Windows, foi preciso reiniciar o computador diversas vezes por causa de um erro.

Após instalar o Docker Desktop no Windows, o Docker te redirecionará para uma página web indicando o link para baixar o WSL 2, um terminal do Linux para rodar dentro do Windows.

Você fará o download deste terminal e poderá seguir os de configuração, indicados no site, caso queira. No meu caso, eu só precisei fazer os passos 4 e 5, ou seja, baixar o programa e rodar o comando. Lembrando que essa etapa adicional é feita apenas para quem usa Windows.

Feita a instalação, podemos abrir o Docker Desktop. Na página inicial, a primeira sugestão na parte superior da tela diz para rodarmos um contêiner ("Run a Sample Container"). Logo abaixo, há um campo editável com uma linha de código e um botão à direita para copiá-lo.

Clicaremos neste botão para copiar o código docker run -d -p 80:80 docker/getting-started. Em seguida, abriremos o Visual Studio e clicaremos no menu superior "Terminal > New Terminal". Ele abrirá um terminal novo na parte inferior da interface. Lá, colaremos o código copiado.

Surgirá o texto "Unable to find imagem 'docker/getting-started:latest' locally". Ele fará o download desta imagem (ou seja, o arquivo compactado) em seguida. Esta é a imagem do projeto "docker/getting-started".

A equipe do Docker criou este projeto e o disponibilizou para nós. Quando usamos o docker run no Getting Started, o Docker baixa um arquivo compactado da internet, mas não da máquina inteira: ele baixa apenas as diferenças entre a sua máquina e o projeto original.

Como dissemos que queríamos rodá-lo ("run"), ele também executa a "máquina virtual".

Atenção: "Máquina virtual" não é o termo mais correto! Estamos fazendo uma analogia para você compreender o que o Docker faz, na prática.

Se você voltar ao Docker Desktop e clicar no menu "Images" à esquerda, verá a imagem "docker/getting-started".

A imagem é o arquivo compactado (zip). O contêiner é uma espécie de "máquina", entre aspas, rodando o arquivo zip. Podemos ter várias máquinas rodando o zip. No meu caso, ele chamou essa máquina de "silly_shockley", mas dará outro nome para a sua.

À direita do nome do contêiner, abaixo da coluna "Port(s)", teremos o número 80:80. Isso quer dizer que ele abriu a porta 80 do servidor web. Há um link sobre o número da porta e, quando clicamos nele, é aberta a página "localhost/tutorial".

Existe um servidor rodando isso na minha máquina, mas ele se encontra no contêiner, ou seja, na "máquina virtual". Se voltarmos ao GitHub Desktop, observaremos que o contêiner está rodando. No menu superior, podemos clicar no botão "Delete" e confirmar clicando em "Delete forever".

Se voltarmos ao navegador e tentarmos atualizar o localhost/tutorial, ele já não existe mais. Obteremos uma página de erro.

Voltando à linha de comando, veremos aquela linha que copiamos originalmente (docker run -d -p 80:80 docker/getting-started). O primeiro número "80" indica a porta em que queremos rodar na máquina do Guilherme, ou seja, o host. Já o segundo número "80", depois dos dois pontos, indica que, dentro do contêiner, temos um servidor rodando na porta 80.

Podemos trocar estas instruções para 8010:80 e tudo aquilo que estiver na porta 8010 na máquina do Guilherme irá para a porta 80 do contêiner. Lembrando que o contêiner 80 é um servidor web. Ao clicar, ele roda rapidamente, pois já tinha o arquivo zip.

Voltando ao navegador, digitamos "localhost:8010/tutorial" e pressionamos a tecla "Enter". Com isso, a página de tutorial estará disponível novamente. "8010" é a porta na minha máquina real.

Se voltarmos ao GitHub Desktop, quando clicamos no link abaixo da coluna "Image", temos acesso a todos os comandos rodados. Ele começa com uma versão alpine do Linux, instala um NGINX (um servidor web), copia vários arquivos e o zip do projeto etc. Aqui aparecem todos os comandos usados para criar o contêiner.

No próximo passo, pegaremos o nosso projeto e criaremos diversos contêiners de uma única vez.

Configurando a aplicação - Log, terminal e stop

Continuando, queria mostrar algumas coisas úteis do Docker Desktop à medida que trabalharmos com sistemas maiores e nos depararmos com erros.

Ao clicar em "Image" no menu lateral esquerdo, tenha em mente que a imagem é um arquivo zip de vários comandos executados. Trata-se de um Linux básico com vários comandos executados e zipados.

Assim, quando clicamos no link abaixo da coluna "Image" do "docker/getting-started", teremos acesso aos comandos executados. Já o contêiner é responsável por rodar o arquivo zip.

Cada vez que criamos um contêiner novo, o Docker gera um nome aleatório por padrão, mas também é possível determinar parâmetros para a criação dos nomes dos contêineres.

Clique no nome do contêiner (e não no link sob a coluna "Image") para ter acesso ao log. Quando rodamos uma imagem do Docker no seu arquivo zip, teremos um arquivo compactado e um comando de execução. Neste projeto, estamos usando o comando que levanta o servidor web.

Portanto, se voltarmos e clicarmos no link abaixo da coluna "Image", perceberemos que há um comando chamado "entrypoint". Ele pede para rodar o comando do arquivo zip, que também será rodado no contêiner.

Voltando no contêiner, clicamos no nome dele e teremos acesso ao log de execução da máquina. Digamos que esteja rodando o NGINX nesta máquina. Conforme vou acessando, o log me mostra as atividades.

Para testar, abriremos o navegador e acessaremos localhost:8010. A página do getting-started irá carregar e o terminal do Docker Desktop exibirá uma nova linha de requisição no log. Assim, cada saída dos comandos executados no contêiner aparece no log.

Se houver algum erro na hora de levantar o contêiner, ele poderá aparecer no log. Isso nem sempre acontece, porque às vezes o erro fica em um arquivo de log, mas se for no output normal, ele aparecerá no log.

No menu superior, a opção "Inspect" nos mostrará algumas variáveis de ambiente, como a versão do NGINX e a porta usada. Em "Terminal", acessamos o contêiner diretamente.

Se digitarmos "Ls" e pressionarmos a tecla "Enter", obteremos os diretórios. Se clicarmos em "Open in external terminal", no canto superior direito, ele abrirá um terminal externo. Estamos no diretório "pwd", ou seja, o diretório raiz, que contém todos os arquivos "zip" dos quais falamos anteriormente.

Com isso, temos à nossa disposição tudo o que o NGINX oferece sem precisar instalá-lo no computador físico. Caso eu tenha dois projetos que precisam do NGINX, cada um com uma configuração diferente, esse problema é resolvido tendo dois dockers, um para cada contêiner.

De volta ao Docker Desktop, o menu superior "Stats" nos oferece dados de memória e CPU utilizados etc.

Agora, clicaremos no botão em formato de engrenagem, de configurações ("Settings"), localizado na parte superior direita do Docker Desktop. Lá, encontraremos várias opções.

A aba à direita chamada "Resources" apresenta o controle de memória. Para trabalhar com isso, abriremos o GitHub do nosso projeto e clicaremos em "Workshop Instructions" e no link em meio ao texto que diz "To start from the beginning click here". Colocaremos o link para iniciar essa etapa e configurar o sistema nas Atividades do curso.

Em recursos, podemos alterar o número de CPUs e a memória mínima. O nosso projeto precisará de 4 GB de memória RAM. Por isso, a recomendação da ThoughtWorks é de, no mínimo:

• 4 CPUs;
• 4 GB de memória RAM;
• 1 Swap;
• 60 GB para disco.

Se você usa o Linux ou o Mac, verá uma tela em que cada configuração é alterada a partir de uma barra deslizante (slider). Se você usa o Windows, o processo é um pouco diferente: precisaremos criar um arquivo em formato .wslconfig file a partir do link disponível na aba Resources.

Ele nos redirecionará para uma página web com instruções. Criaremos um arquivo formato .wslconfig e colocaremos três linhas de configuração simples nele, para indicar a memória, o Swap e assim por diante.

Criado este arquivo, basta reiniciar o terminal do Linux no Windows (WSL). Para isso, usaremos o comando wsl --shutdown no terminal e reiniciaremos o computador. Eu precisei reiniciar a máquina duas vezes para conseguir concluir o processo de configuração.

Se clicarmos no ícone de uma seta do lado direito da barra de tarefas para mostrar os ícones ocultos e dermos um clique no ícone do Docker Desktop que aparece lá, encontraremos a opção "Switch to Windows containers" (Trocar para contêineres do Windows).

Se os contêineres usados forem os do Windows, essa opção aparecerá como "Switch to Linux containers". Por enquanto, queremos usar os contêineres do próprio Linux, então não precisamos fazer nenhuma alteração.

Um detalhe importante para qualquer sistema operacional é que, saindo das configurações e abrindo a aba Containers no menu lateral esquerdo, podemos clicar sobre o nome do contêiner e explorá-lo.

Também é possível clicar na caixa de seleção ao lado do nome do contêiner e apertar o botão com um ícone quadrado, indicando que desejamos que aquele contêiner pare de rodar.

No próximo passo, rodaremos todo o machine learning do projeto.

Sobre o curso Continuous Delivery for Machine Learning: completando o Pipeline

O curso Continuous Delivery for Machine Learning: completando o Pipeline possui 113 minutos de vídeos, em um total de 52 atividades. Gostou? Conheça nossos outros cursos de Machine Learning em Data Science, ou leia nossos artigos de Data Science.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Configurando a aplicação
• Entendendo a aplicação
• Alterando a aplicação
• Testando a aplicação
• Monitorando a aplicação