One place for hosting & domains

      Como Instalar e Utilizar o TensorFlow no Ubuntu 18.04


      Introdução

      O TensorFlow é um software open-source de aprendizado de máquina ou machine learning usado para treinar redes neurais. As redes neurais do TensorFlow são expressas sob a forma de gráficos de fluxo de dados stateful. Cada nó no gráfico representa as operações realizadas por redes neurais em matrizes multidimensionais. Essas matrizes multidimensionais são comumente conhecidas como “tensores”, daí o nome TensorFlow.

      O TensorFlow é um sistema de software de deep learning. Ele funciona bem para a recuperação de informações, conforme demonstrado pelo Google na forma como eles pesquisam o ranking em seu sistema de inteligência artificial de machine learning, RankBrain. O TensorFlow pode realizar reconhecimento de imagem, conforme mostrado no Inception do Google, bem como reconhecimento de áudio em linguagem humana. Também é útil na resolução de outros problemas não específicos de machine learning, como equações diferenciais parciais.

      A arquitetura do TensorFlow permite o deployment em várias CPUs ou GPUs em um desktop, servidor ou dispositivo móvel. Existem também extensões para integração com CUDA, uma plataforma de computação paralela da Nvidia. Isso fornece aos usuários que estão fazendo deploy em uma GPU acesso direto ao conjunto de instruções virtuais e outros elementos da GPU que são necessários para tarefas computacionais paralelas.

      Neste tutorial, vamos instalar a versão “CPU support only” do TensorFlow. Essa instalação é ideal para pessoas que querem instalar e usar o TensorFlow, mas que não têm uma placa de vídeo Nvidia ou não precisam executar aplicações críticas em termos de desempenho.

      Você pode instalar o TensorFlow de várias maneiras. Cada método tem um caso de uso e um ambiente de desenvolvimento diferentes:

      • Python e Virtualenv: Nesta abordagem, você instala o TensorFlow e todos os pacotes necessários para utilizá-lo em um ambiente virtual do Python. Isso isola seu ambiente do TensorFlow de outros programas do Python na mesma máquina.
      • Native pip: Neste método, você instala o TensorFlow em seu sistema de maneira global. Isso é recomendado para pessoas que querem disponibilizar o TensorFlow para todos em um sistema multiusuário. Esse método de instalação não isola o TensorFlow em um ambiente de contenção e pode interferir em outras instalações ou bibliotecas do Python.
      • Docker: O Docker é um ambiente runtime de container e isola completamente seu conteúdo dos pacotes preexistentes em seu sistema. Nesse método, você usa um container do Docker que contém o TensorFlow e todas as suas dependências. Esse método é ideal para incorporar o TensorFlow a uma arquitetura de aplicações maior que já usa o Docker. No entanto, o tamanho da imagem do Docker será bem grande.

      Neste tutorial, você instalará o TensorFlow em um ambiente virtual do Python com virtualenv. Essa abordagem isola a instalação do TensorFlow e coloca tudo em funcionamento rapidamente. Depois de concluir a instalação, você fará a sua validação executando um pequeno programa do TensorFlow e, em seguida, utilizará o TensorFlow para realizar o reconhecimento de imagem.

      Pré-requisitos

      Antes de começar este tutorial, você precisará do seguinte:

      Passo 1 — Instalando o TensorFlow

      Nesta etapa, vamos criar um ambiente virtual e instalar o TensorFlow.

      Primeiro, crie um diretório de projeto. Vamos chamá-lo de tf-demo para fins de demonstração, mas escolha um nome de diretório que seja significativo para você:

      Navegue até o seu diretório tf-demo recém-criado:

      Em seguida, crie um novo ambiente virtual chamado tensorflow-dev, por exemplo. Execute o seguinte comando para criar o ambiente:

      • python3 -m venv tensorflow-dev

      Isto cria um novo diretório tensorflow-dev que conterá todos os pacotes que você instalar enquanto este ambiente estiver ativado. Também inclui o pip e uma versão independente do Python.

      Agora ative seu ambiente virtual:

      • source tensorflow-dev/bin/activate

      Uma vez ativado, você verá algo semelhante a isso no seu terminal:

      (tensorflow-dev)nome_de_usuário@hostname:~/tf-demo $
      

      Agora você pode instalar o TensorFlow em seu ambiente virtual.

      Execute o seguinte comando para instalar e atualizar para a versão mais recente do TensorFlow disponível em PyPi:

      • pip install --upgrade tensorflow

      O TensorFlow será instalado, e você deverá obter uma saída que indique que a instalação, juntamente com quaisquer pacotes dependentes, foi bem-sucedida.

      Output

      ... Successfully installed absl-py-0.7.1 astor-0.7.1 gast-0.2.2 grpcio-1.19.0 h5py-2.9.0 keras-applications-1.0.7 keras-preprocessing-1.0.9 markdown-3.0.1 mock-2.0.0 numpy-1.16.2 pbr-5.1.3 protobuf-3.7.0 setuptools-40.8.0 tensorboard-1.13.1 tensorflow-1.13.1 tensorflow-estimator-1.13.0 termcolor-1.1.0 werkzeug-0.15.0 wheel-0.33.1 ... Successfully installed bleach-1.5.0 enum34-1.1.6 html5lib-0.9999999 markdown-2.6.9 numpy-1.13.3 protobuf-3.5.0.post1 setuptools-38.2.3 six-1.11.0 tensorflow-1.4.0 tensorflow-tensorboard-0.4.0rc3 werkzeug-0.12.2 wheel-0.30.0

      Você pode desativar seu ambiente virtual a qualquer momento usando o seguinte comando:

      Para reativar o ambiente posteriormente, navegue até o diretório do projeto e execute source tensorflow-dev/bin/activate.

      Agora que você instalou o TensorFlow, vamos garantir que a instalação esteja funcionando.

      Passo 2 — Validando a Instalação

      Para validar a instalação do TensorFlow, vamos executar um programa simples como um usuário não-root. Usaremos o exemplo canônico de iniciante de "Hello, world!" como uma forma de validação. Em vez de criar um arquivo em Python, criaremos esse programa usando o console interativo do Python.

      Para escrever o programa, inicie seu interpretador Python:

      Você verá o seguinte prompt aparecer no seu terminal:

      >>>
      

      Este é o prompt do interpretador Python e indica que ele está pronto para que você comece a inserir algumas instruções do Python.

      Primeiro, digite esta linha para importar o pacote TensorFlow e disponibilizá-lo como a variável local tf. Pressione ENTER depois de digitar a linha de código:

      Em seguida, adicione esta linha de código para definir a mensagem "Hello, world!":

      • hello = tf.constant("Hello, world!")

      Em seguida, crie uma nova sessão do TensorFlow e atribua-a à variável sess:

      Nota: Dependendo do seu ambiente, você poderá ver esta saída:

      Output

      2019-03-20 16:22:45.956946: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use SSE4.1 instructions, but these are available on your machine and could speed up CPU computations. 2019-03-20 16:22:45.957158: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use SSE4.2 instructions, but these are available on your machine and could speed up CPU computations. 2019-03-20 16:22:45.957282: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use AVX instructions, but these are available on your machine and could speed up CPU computations. 2019-03-20 16:22:45.957404: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use AVX2 instructions, but these are available on your machine and could speed up CPU computations. 2019-03-20 16:22:45.957527: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use FMA instructions, but these are available on your machine and could speed up CPU computations.

      Isso lhe diz que você tem um conjunto de instruções que tem o potencial para ser otimizado para um melhor desempenho com o TensorFlow. Se você vir isso, poderá ignorar com segurança e continuar.

      Por fim, insira essa linha de código para imprimir o resultado da execução da sessão hello do TensorFlow que você construiu nas suas linhas de código anteriores:

      No Python 3, sess.run() irá retornar uma byte string, que será renderizada como b'Hello, world!' se você executar print(sess.run(hello)) sozinho. Para retornar Hello, world! como uma string, vamos adicionar o método decode().

      • print(sess.run(hello).decode())

      Você verá essa saída no seu console:

      Output

      Hello, world!

      Isso indica que tudo está funcionando e que você pode começar a usar o TensorFlow.

      Saia do console interativo do Python pressionando CTRL+D ou digitando quit().

      A seguir, vamos usar a API de reconhecimento de imagem do TensorFlow para nos familiarizarmos com o TensorFlow.

      Passo 3 — Usando o TensorFlow para Reconhecimento de Imagem

      Agora que o TensorFlow está instalado e você o validou executando um programa simples, podemos dar uma olhada em seus recursos de reconhecimento de imagem.

      Para classificar uma imagem, você precisa treinar um modelo. Então você precisa escrever algum código para usar o modelo. Para aprender mais sobre conceitos de machine learning, considere a leitura de “An Introduction to Machine Learning.”

      O TensorFlow fornece um repositório de modelos e exemplos, incluindo código e um modelo treinado para classificar imagens.

      Use o Git para clonar o repositório de modelos do TensorFlow do GitHub no diretório do seu projeto:

      • git clone https://github.com/tensorflow/models.git

      Você receberá a seguinte saída enquanto o Git clona o repositório em uma nova pasta chamada models:

      Output

      Cloning into 'models'... remote: Enumerating objects: 32, done. remote: Counting objects: 100% (32/32), done. remote: Compressing objects: 100% (26/26), done. remote: Total 24851 (delta 17), reused 12 (delta 6), pack-reused 24819 Receiving objects: 100% (24851/24851), 507.78 MiB | 32.73 MiB/s, done. Resolving deltas: 100% (14629/14629), done. Checking out files: 100% (2858/2858), done.

      Mude para o diretório models/tutorials/image/imagenet:

      • cd models/tutorials/image/imagenet

      Este diretório contém o arquivo classify_image.py que usa o TensorFlow para reconhecer imagens. Este programa faz o download de um modelo treinado a partir de tensorflow.org em sua primeira execução. O download desse modelo exige que você tenha 200 MB de espaço livre disponível no disco.

      Neste exemplo, vamos classificar uma imagem pré-fornecida de um Panda. Execute este comando para executar o programa classificador de imagens:

      Você receberá uma saída semelhante a esta:

      Output

      giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca (score = 0.89107) indri, indris, Indri indri, Indri brevicaudatus (score = 0.00779) lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens (score = 0.00296) custard apple (score = 0.00147) earthstar (score = 0.00117)

      Você classificou sua primeira imagem usando os recursos de reconhecimento de imagem do TensorFlow.

      Se você quiser usar outra imagem, você pode fazer isso adicionando o argumento -- image_file ao seu comando python3 classify_image.py. Para o argumento, você passaria o caminho absoluto do arquivo de imagem.

      Conclusão

      Neste tutorial, você instalou o TensorFlow em um ambiente virtual do Python e validou o funcionamento do TensorFlow executando alguns exemplos. Agora você possui ferramentas que possibilitam a exploração de tópicos adicionais, incluindo Redes Neurais Convolucionais e Word Embeddings ou Vetores de Palavras.

      O guia do programador do TensorFlow fornece um recurso útil e uma referência para o desenvolvimento do TensorFlow. Você também pode explorar o Kaggle, um ambiente competitivo para a aplicação prática de conceitos de machine learning que o colocam contra outros entusiastas de machine learning, ciência de dados e estatística. Eles têm um wiki robusto onde você pode explorar e compartilhar soluções, algumas das quais estão na vanguarda das técnicas estatísticas e de machine learning.



      Source link

      Como Instalar o Java com `apt` no Ubuntu 18.04


      O autor selecionou o Open Internet/Free Speech Fund para receber uma doação de $100 como parte do programa Escreva para DOações.

      Introdução

      Java e a JVM (Java’s virtual machine) são necessários para utilizar vários tipos de software, incluindo o Tomcat, Jetty, Glassfish, Cassandra e Jenkins.

      Neste guia, você irá instalar várias versões do Java Runtime Environment (JRE) e do Java Developer Kit (JDK) utilizando o apt. Você irá instalar o OpenJDK e também os pacotes oficiais da Oracle. Em seguida, você irá selecionar a versão que você deseja utilizar em seus projetos. Quando você finalizar o guia, você será capaz de utilizar o JDK para desenvolver seus programas ou utilizar o Java Runtime para rodar seus programas.

      Pré-requisitos

      Para seguir ester tutorial, você precisará de:

      Instalando o JRE/JDK Padrão

      A opção mais fácil para instalar o Java é utilizando o pacote que vem com o Ubuntu. Por padrão, o Ubuntu 18.04 inclui o OpenJDK, que é a alternativa open-source do JRE e JDK.

      Esse pacote irá instalar ou o OpenJDK 10 ou o 11.

      • Antes de Setembro de 2018, ele irá instalar o OpenJDK 10.
      • Depois de Setembro de 2018, ele irá instalar o OpenJDK 11.

      Para instalar essa versão, primeiro precisamos atualizar a lista de pacotes do apt:

      Depois, checar se o Java já está instalado:

      Se o Java não estiver instalado, você verá a seguinte mensagem:

      Output

      Command 'java' not found, but can be installed with: apt install default-jre apt install openjdk-11-jre-headless apt install openjdk-8-jre-headless

      Execute o seguinte comando para instalar o OpenJDK:

      • sudo apt install default-jre

      Esse comando irá instalar o Java Runtime Environment (JRE). Isso vai permitir que você execute praticamente todos os programas em Java.

      Verifique a instalação com:

      Você verá a seguinte mensagem:

      Output

      openjdk version "10.0.2" 2018-07-17 OpenJDK Runtime Environment (build 10.0.2+13-Ubuntu-1ubuntu0.18.04.4) OpenJDK 64-Bit Server VM (build 10.0.2+13-Ubuntu-1ubuntu0.18.04.4, mixed mode)

      Você talvez precise do Java Development Kit (JDK) junto do JRE para poder compilar e rodar algum programa específico em Java. Para instalar o JDK, execute os seguintes comandos, que também irão instalar o JRE:

      • sudo apt install default-jdk

      Verifique se o JDK foi instalado checando a versão do javac, o compilador Java:

      Você verá a seguinte mensagem:

      Output

      javac 10.0.2

      A seguir, veremos como especificar uma versão do OpenJDK que nós queremos instalar.

      Instalando uma versão especifica do OpenJDK

      OpenJDK 8

      Java 8 é a versão Long Term Support (Suporte de longo prazo) atual e ainda é amplamente suportada, apesar da manutenção pública terminar em Janeiro de 2019. Para instalar o OpenJDK 8, execute o seguinte comando:

      • sudo apt install openjdk-8-jdk

      Verifique se foi instalado com:

      Você verá a seguinte mensagem:

      Output

      openjdk version "1.8.0_191" OpenJDK Runtime Environment (build 1.8.0_191-8u191-b12-2ubuntu0.18.04.1-b12) OpenJDK 64-Bit Server VM (build 25.191-b12, mixed mode)

      Também é possível instalar somente o JRE, o que você pode fazer executando o seguinte comando sudo apt install openjdk-8-jre.

      OpenJDK 10/11

      Os repositórios do Ubuntu possuem os pacotes que instalarão o Java 10 ou o 11. Até Setembro de 2018, esse pacote irá instalar o OpenJDK 10. Assim que o Java 11 for lançado, esse pacote instalará o Java 11.

      Para instalar o OpenJDK 10/10, execute o seguinte comando:

      • sudo apt install openjdk-11-jdk

      Para instalar somente o JRE, use o seguinte comando:

      • sudo apt install openjdk-11-jre

      A seguir, vamos ver como instalar o JDK e o JRE oficiais da Oracle.

      Instalando o Oracle JDK

      Se quiser instalar o Oracle JDK, que é a versão oficial distribuída pela Oracle, você precisará adicionar um novo repositório de pacotes para a versão que você gostaria de instalar.

      Para instalar o Java 8, que é a última versão LTS, primeiramente adicione o repositório do pacote:

      • sudo add-apt-repository ppa:webupd8team/java

      Quando você adicionar o repositório, você verá uma mensagem parecida com essa:

      output

      Oracle Java (JDK) Installer (automatically downloads and installs Oracle JDK8). There are no actual Java files in this PPA. Important -> Why Oracle Java 7 And 6 Installers No Longer Work: http://www.webupd8.org/2017/06/why-oracle-java-7-and-6-installers-no.html Update: Oracle Java 9 has reached end of life: http://www.oracle.com/technetwork/java/javase/downloads/jdk9-downloads-3848520.html The PPA supports Ubuntu 18.10, 18.04, 16.04, 14.04 and 12.04. More info (and Ubuntu installation instructions): - http://www.webupd8.org/2012/09/install-oracle-java-8-in-ubuntu-via-ppa.html Debian installation instructions: - Oracle Java 8: http://www.webupd8.org/2014/03/how-to-install-oracle-java-8-in-debian.html For Oracle Java 11, see a different PPA -> https://www.linuxuprising.com/2018/10/how-to-install-oracle-java-11-in-ubuntu.html More info: https://launchpad.net/~webupd8team/+archive/ubuntu/java Press [ENTER] to continue or Ctrl-c to cancel adding it.

      Pressione ENTER para continuar. Depois atualize sua lista de pacotes:

      Quando a lista de pacotes atualizar, instale o Java 8:

      • sudo apt install oracle-java8-installer

      Seu sistema irá realizar o download do JDK da Oracle e irá solicitar que você aceite os termos de licença. Aceite os termos e o JDK será instalado.

      Agora vamos ver como selecionar qual versão do Java você deseja utilizar.

      Gerenciando o Java

      Você pode ter múltiplas instalações do Java em um servidor. Você pode configurar qual versão será utilizada por padrão no terminal, usando o comando update-alternatives.

      • sudo update-alternatives --config java

      Será assim que a saída vai parecer se você instalou todas as versões de Java desse tutorial:

      Output

      There are 3 choices for the alternative java (providing /usr/bin/java). Selection Path Priority Status ------------------------------------------------------------ * 0 /usr/lib/jvm/java-11-openjdk-amd64/bin/java 1101 auto mode 1 /usr/lib/jvm/java-11-openjdk-amd64/bin/java 1101 manual mode 2 /usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java 1081 manual mode 3 /usr/lib/jvm/java-8-oracle/jre/bin/java 1081 manual mode

      Escolha o número que está associado com a versão do Java que será utilizada como padrão, ou pressione ENTER para deixar a configuração atual no lugar.

      Você pode usar isso para outros comandos Java, como o compilador (javac):

      • sudo update-alternatives --config javac

      Outros comandos para os quais esse comando pode ser utilizado incluem, mas não ficam limitados a: keytool, javadoc e jarsigner.

      Configurando a Variavel de Ambiente JAVA_HOME

      Muitos programas escritos em Java, utilizam a variável de ambiente JAVA_HOME para determinar o local de instalação do Java.

      Para configurar esta variável de ambiente, primeiramente defina onde o Java está instalado. Utilize o comando update-alternatives:

      • sudo update-alternatives --config java

      Esse comando mostra cada instalação do Java junto com seu caminho de instalação:

      Output

      There are 3 choices for the alternative java (providing /usr/bin/java). Selection Path Priority Status ------------------------------------------------------------ * 0 /usr/lib/jvm/java-11-openjdk-amd64/bin/java 1101 auto mode 1 /usr/lib/jvm/java-11-openjdk-amd64/bin/java 1101 manual mode 2 /usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java 1081 manual mode 3 /usr/lib/jvm/java-8-oracle/jre/bin/java 1081 manual mode Press <enter> to keep the current choice[*], or type selection number:

      Nesse caso, os caminhos de instalação são os seguintes:

      1. OpenJDK 11 está localizado em /usr/lib/jvm/java-11-openjdk-amd64/bin/java.
      2. OpenJDK 8 está localizado em /usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java.
      3. Oracle Java 8 está localizado em /usr/lib/jvm/java-8-oracle/jre/bin/java.

      Copie o caminho da instalação que você deseja utilizar. Depois abra /etc/environment utilizando o nano ou o seu editor de texto favorito:

      • sudo nano /etc/environment

      No final desse arquivo, adicione a seguinte linha, certificando-se de substituir o caminho destacado com o que você copiou do seu sistema:

      /etc/environment

      JAVA_HOME="/usr/lib/jvm/java-11-openjdk-amd64/bin/"
      

      Ao modificar esse arquivo você irá configurar o caminho JAVA_HOME para todos os usuários do seu sistema.

      Salve o arquivo e saia do editor de texto.

      Agora recarregue arquivo para aplicar as mudanças para sua sessão atual:

      Verifique se a sua variável de ambiente foi configurada:

      Você verá o caminho que você acabou de configurar:

      Output

      /usr/lib/jvm/java-11-openjdk-amd64/bin/

      Os outros usuários precisaram executar o comando source /etc/environment ou desconectar e logar novamente para aplicar essa configuração.

      Conclusão

      Nesse tutorial você instalou múltiplas versões do Java e aprendeu como gerenciá-las. Você agora pode instalar os programas que rodam em Java, tais como o Tomcat, Jetty, Glassfish, Cassandra ou Jenkins.



      Source link

      Como Otimizar Imagens Docker para Produção


      O autor escolheu a Code.org para receber uma doação como parte do programa Write for DOnations.

      Introdução

      Em um ambiente de produção, o Docker facilita a criação, o deployment e a execução de aplicações dentro de containers. Os containers permitem que os desenvolvedores reúnam aplicações e todas as suas principais necessidades e dependências em um único pacote que você pode transformar em uma imagem Docker e replicar. As imagens Docker são construídas a partir de Dockerfiles. O Dockerfile é um arquivo onde você define como será a imagem, qual sistema operacional básico ela terá e quais comandos serão executados dentro dela.

      Imagens Docker muito grandes podem aumentar o tempo necessário para criar e enviar imagens entre clusters e provedores de nuvem. Se, por exemplo, você tem uma imagem do tamanho de um gigabyte para enviar toda vez que um de seus desenvolvedores aciona uma compilação, a taxa de transferência que você cria em sua rede aumentará durante o processo de CI/CD, tornando sua aplicação lenta e, consequentemente, custando seus recursos. Por causa disso, as imagens Docker adequadas para produção devem ter apenas as necessidades básicas instaladas.

      Existem várias maneiras de diminuir o tamanho das imagens Docker para otimizá-las para a produção. Em primeiro lugar, essas imagens geralmente não precisam de ferramentas de compilação para executar suas aplicações e, portanto, não há necessidade de adicioná-las. Através do uso de um processo de construção multi-stage, você pode usar imagens intermediárias para compilar e construir o código, instalar dependências e empacotar tudo no menor tamanho possível, depois copiar a versão final da sua aplicação para uma imagem vazia sem ferramentas de compilação. Além disso, você pode usar uma imagem com uma base pequena, como o Alpine Linux. O Alpine é uma distribuição Linux adequada para produção, pois possui apenas as necessidades básicas que sua aplicação precisa para executar.

      Neste tutorial, você otimizará as imagens Docker em algumas etapas simples, tornando-as menores, mais rápidas e mais adequadas à produção. Você construirá imagens para um exemplo de API em Go em vários containers Docker diferentes, começando com o Ubuntu e imagens específicas de linguagens, e então passando para a distribuição Alpine. Você também usará compilações multi-stage para otimizar suas imagens para produção. O objetivo final deste tutorial é mostrar a diferença de tamanho entre usar imagens padrão do Ubuntu e as equivalentes otimizadas, e mostrar a vantagem das compilações em vários estágios (multi-stage). Depois de ler este tutorial, você poderá aplicar essas técnicas aos seus próprios projetos e pipelines de CI/CD.

      Nota: Este tutorial utiliza uma API escrita em Go como um exemplo. Esta simples API lhe dará uma compreensão clara de como você abordaria a otimização de microsserviços em Go com imagens Docker. Embora este tutorial use uma API Go, você pode aplicar esse processo a praticamente qualquer linguagem de programação.

      Pré-requisitos

      Antes de começar, você precisará de:

      Passo 1 — Baixando a API Go de Exemplo

      Antes de otimizar sua imagem Docker, você deve primeiro fazer o download da API de exemplo, a partir da qual você construirá suas imagens Docker. O uso de uma API Go simples mostrará todas as principais etapas de criação e execução de uma aplicação dentro de um container Docker. Este tutorial usa o Go porque é uma linguagem compilada como o C++ ou Java, mas ao contrário dele, tem uma pegada muito pequena.

      No seu servidor, comece clonando a API Go de exemplo:

      • git clone https://github.com/do-community/mux-go-api.git

      Depois de clonar o projeto, você terá um diretório chamado mux-go-api em seu servidor. Mova-se para este diretório com cd:

      Este será o diretório home do seu projeto. Você construirá suas imagens Docker a partir desse diretório. Dentro dele você encontrará o código fonte para uma API escrita em Go no arquivo api.go. Embora essa API seja mínima e tenha apenas alguns endpoints, ela será apropriada para simular uma API pronta para produção para os propósitos deste tutorial.

      Agora que você baixou a API Go de exemplo, você está pronto para criar uma imagem base do Ubuntu no Docker, com a qual você poderá comparar as imagens posteriores e otimizadas.

      Passo 2 — Construindo uma Imagem Base do Ubuntu

      Para a sua primeira imagem Docker, será útil ver como ela é quando você começa com uma imagem base do Ubuntu. Isso irá empacotar sua API de exemplo em um ambiente similar ao software que você já está rodando no seu servidor Ubuntu. Isso irá empacotar sua API de exemplo em um ambiente similar ao software que você já está rodando no seu servidor Ubuntu. Dentro da imagem, você instalará os vários pacotes e módulos necessários para executar sua aplicação. Você descobrirá, no entanto, que esse processo cria uma imagem bastante pesada do Ubuntu que afetará o tempo de compilação e a legibilidade do código do seu Dockerfile.

      Comece escrevendo um Dockerfile que instrui o Docker a criar uma imagem do Ubuntu, instalar o Go e executar a API de exemplo. Certifique-se de criar o Dockerfile no diretório do repositório clonado. Se você clonou no diretório home, ele deve ser $HOME/mux-go-api.

      Crie um novo arquivo chamado Dockerfile.ubuntu. Abra-o no nano ou no seu editor de texto favorito:

      • nano ~/mux-go-api/Dockerfile.ubuntu

      Neste Dockerfile, você irá definir uma imagem do Ubuntu e instalar o Golang. Em seguida, você vai continuar a instalar as dependências necessárias e construir o binário. Adicione o seguinte conteúdo ao Dockerfile.ubuntu:

      ~/mux-go-api/Dockerfile.ubuntu

      FROM ubuntu:18.04
      
      RUN apt-get update -y 
        && apt-get install -y git gcc make golang-1.10
      
      ENV GOROOT /usr/lib/go-1.10
      ENV PATH $GOROOT/bin:$PATH
      ENV GOPATH /root/go
      ENV APIPATH /root/go/src/api
      
      WORKDIR $APIPATH
      COPY . .
      
      RUN  
        go get -d -v 
        && go install -v 
        && go build
      
      EXPOSE 3000
      CMD ["./api"]
      

      Começando do topo, o comando FROM especifica qual sistema operacional básico a imagem terá. A seguir, o comando RUN instala a linguagem Go durante a criação da imagem. ENV define as variáveis de ambiente específicas que o compilador Go precisa para funcionar corretamente. WORKDIR especifica o diretório onde queremos copiar o código, e o comando COPY pega o código do diretório onde o Dockerfile.ubuntu está e o copia para a imagem. O comando RUN final instala as dependências do Go necessárias para o código-fonte compilar e executar a API.

      Nota: Usar os operadores && para unir os comandos RUN é importante para otimizar os Dockerfiles, porque todo comando RUN criará uma nova camada, e cada nova camada aumentará o tamanho da imagem final.

      Salve e saia do arquivo. Agora você pode executar o comando build para criar uma imagem Docker a partir do Dockerfile que você acabou de criar:

      • docker build -f Dockerfile.ubuntu -t ubuntu .

      O comando build constrói uma imagem a partir de um Dockerfile. A flag -f especifica que você deseja compilar a partir do arquivo Dockerfile.ubuntu, enquanto -t significa tag, o que significa que você está marcando a imagem com o nome ubuntu. O ponto final representa o contexto atual onde o Dockerfile.ubuntu está localizado.

      Isso vai demorar um pouco, então sinta-se livre para fazer uma pausa. Quando a compilação estiver concluída, você terá uma imagem Ubuntu pronta para executar sua API. Mas o tamanho final da imagem pode não ser ideal; qualquer coisa acima de algumas centenas de MB para essa API seria considerada uma imagem excessivamente grande.

      Execute o seguinte comando para listar todas as imagens Docker e encontrar o tamanho da sua imagem Ubuntu:

      Você verá a saída mostrando a imagem que você acabou de criar:

      Output

      REPOSITORY TAG IMAGE ID CREATED SIZE ubuntu latest 61b2096f6871 33 seconds ago 636MB . . .

      Como é destacado na saída, esta imagem tem um tamanho de 636MB para uma API Golang básica, um número que pode variar um pouco de máquina para máquina. Em múltiplas compilações, esse grande tamanho afetará significativamente os tempos de deployment e a taxa de transferência da rede.

      Nesta seção, você construiu uma imagem Ubuntu com todas as ferramentas e dependências necessárias do Go para executar a API que você clonou no Passo 1. Na próxima seção, você usará uma imagem Docker pré-criada e específica da linguagem para simplificar seu Dockerfile e agilizar o processo de criação.

      Passo 3 — Construindo uma Imagem Base Específica para a Linguagem

      Imagens pré-criadas são imagens básicas comuns que os usuários modificaram para incluir ferramentas específicas para uma situação. Os usuários podem, então, enviar essas imagens para o repositório de imagens Docker Hub, permitindo que outros usuários usem a imagem compartilhada em vez de ter que escrever seus próprios Dockerfiles individuais. Este é um processo comum em situações de produção, e você pode encontrar várias imagens pré-criadas no Docker Hub para praticamente qualquer caso de uso. Neste passo, você construirá sua API de exemplo usando uma imagem específica do Go que já tenha o compilador e as dependências instaladas.

      Com imagens base pré-criadas que já contêm as ferramentas necessárias para criar e executar sua aplicação, você pode reduzir significativamente o tempo de criação. Como você está começando com uma base que tem todas as ferramentas necessárias pré-instaladas, você pode pular a adição delas ao seu Dockerfile, fazendo com que pareça muito mais limpo e, finalmente, diminuindo o tempo de construção.

      Vá em frente e crie outro Dockerfile e nomeie-o como Dockerfile.golang. Abra-o no seu editor de texto:

      • nano ~/mux-go-api/Dockerfile.golang

      Este arquivo será significativamente mais conciso do que o anterior, porque tem todas as dependências, ferramentas e compilador específicos do Go pré-instalados.

      Agora, adicione as seguintes linhas:

      ~/mux-go-api/Dockerfile.golang

      FROM golang:1.10
      
      WORKDIR /go/src/api
      COPY . .
      
      RUN 
          go get -d -v 
          && go install -v 
          && go build
      
      EXPOSE 3000
      CMD ["./api"]
      

      Começando do topo, você verá que a instrução FROM agora é golang:1.10. Isso significa que o Docker buscará uma imagem Go pré-criada do Docker Hub que tenha todas as ferramentas Go necessárias já instaladas.

      Agora, mais uma vez, compile a imagem do Docker com:

      • docker build -f Dockerfile.golang -t golang .

      Verifique o tamanho final da imagem com o seguinte comando:

      Isso produzirá uma saída semelhante à seguinte:

      Output

      REPOSITORY TAG IMAGE ID CREATED SIZE golang latest eaee5f524da2 40 seconds ago 744MB . . .

      Embora o próprio Dockerfile seja mais eficiente e o tempo de compilação seja menor, o tamanho total da imagem aumentou. A imagem pré-criada do Golang está em torno de 744MB, uma quantidade significativa.

      Essa é a maneira preferida de criar imagens Docker. Ela lhe dá uma imagem base que a comunidade aprovou como o padrão a ser usado para a linguagem especificada, neste caso, Go. No entanto, para tornar uma imagem pronta para produção, você precisa cortar partes que a aplicação em execução não precisa.

      Tenha em mente que o uso dessas imagens pesadas é bom quando você não tem certeza sobre suas necessidades. Sinta-se à vontade para usá-las como containers descartáveis, bem como a base para a construção de outras imagens. Para fins de desenvolvimento ou teste, onde você não precisa pensar em enviar imagens pela rede, é perfeitamente aceitável usar imagens pesadas. Mas, se você quiser otimizar os deployments, precisará fazer o seu melhor para tornar suas imagens o menor possível.

      Agora que você testou uma imagem específica da linguagem, você pode passar para a próxima etapa, na qual usará a distribuição leve do Alpine Linux como uma imagem base para tornar a imagem Docker mais leve.

      Passo 4 — Construindo Imagens Base do Alpine

      Um dos passos mais fáceis para otimizar as imagens Docker é usar imagens base menores. Alpine é uma distribuição Linux leve projetada para segurança e eficiência de recursos. A imagem Docker do Alpine usa musl libc e BusyBox para ficar compacta, exigindo não mais que 8MB em um container para ser executada. O tamanho minúsculo é devido a pacotes binários sendo refinados e divididos, dando a você mais controle sobre o que você instala, o que mantém o ambiente menor e mais eficiente possível.

      O processo de criação de uma imagem Alpine é semelhante ao modo como você criou a imagem do Ubuntu no Passo 2. Primeiro, crie um novo arquivo chamado Dockerfile.alpine:

      • nano ~/mux-go-api/Dockerfile.alpine

      Agora adicione este trecho:

      ~/mux-go-api/Dockerfile.alpine

      FROM alpine:3.8
      
      RUN apk add --no-cache 
          ca-certificates 
          git 
          gcc 
          musl-dev 
          openssl 
          go
      
      ENV GOPATH /go
      ENV PATH $GOPATH/bin:/usr/local/go/bin:$PATH
      ENV APIPATH $GOPATH/src/api
      RUN mkdir -p "$GOPATH/src" "$GOPATH/bin" "$APIPATH" && chmod -R 777 "$GOPATH"
      
      WORKDIR $APIPATH
      COPY . .
      
      RUN 
          go get -d -v 
          && go install -v 
          && go build
      
      EXPOSE 3000
      CMD ["./api"]
      

      Aqui você está adicionando o comando apk add para utilizar o gerenciador de pacotes do Alpine para instalar o Go e todas as bibliotecas que ele requer. Tal como acontece com a imagem do Ubuntu, você precisa definir as variáveis de ambiente também.

      Vá em frente e compile a imagem:

      • docker build -f Dockerfile.alpine -t alpine .

      Mais uma vez, verifique o tamanho da imagem:

      Você receberá uma saída semelhante à seguinte:

      Output

      REPOSITORY TAG IMAGE ID CREATED SIZE alpine latest ee35a601158d 30 seconds ago 426MB . . .

      O tamanho caiu para cerca de 426MB.

      O tamanho reduzido da imagem base Alpine reduziu o tamanho final da imagem, mas há mais algumas coisas que você pode fazer para torná-la ainda menor.

      A seguir, tente usar uma imagem Alpine pré-criada para o Go. Isso tornará o Dockerfile mais curto e também reduzirá o tamanho da imagem final. Como a imagem Alpine pré-criada para o Go é construída com o Go compilado dos fontes, sua tamanho é significativamente menor.

      Comece criando um novo arquivo chamado Dockerfile.golang-alpine:

      • nano ~/mux-go-api/Dockerfile.golang-alpine

      Adicione o seguinte conteúdo ao arquivo:

      ~/mux-go-api/Dockerfile.golang-alpine

      FROM golang:1.10-alpine3.8
      
      RUN apk add --no-cache --update git
      
      WORKDIR /go/src/api
      COPY . .
      
      RUN go get -d -v 
        && go install -v 
        && go build
      
      EXPOSE 3000
      CMD ["./api"]
      

      As únicas diferenças entre Dockerfile.golang-alpine e Dockerfile.alpine são o comando FROM e o primeiro comando RUN. Agora, o comando FROM especifica uma imagem golang com a tag 1.10-alpine3.8 e RUN só tem um comando para a instalação do Git. Você precisa do Git para o comando go get para trabalhar no segundo comando RUN na parte inferior do Dockerfile.golang-alpine.

      Construa a imagem com o seguinte comando:

      • docker build -f Dockerfile.golang-alpine -t golang-alpine .

      Obtenha sua lista de imagens:

      Você receberá a seguinte saída:

      Output

      REPOSITORY TAG IMAGE ID CREATED SIZE golang-alpine latest 97103a8b912b 49 seconds ago 288MB

      Agora o tamanho da imagem está em torno de 288MB.

      Mesmo que você tenha conseguido reduzir bastante o tamanho, há uma última coisa que você pode fazer para preparar a imagem para a produção. É chamado de uma compilação de múltiplos estágios ou multi-stage. Usando compilações multi-stage, você pode usar uma imagem para construir a aplicação enquanto usa outra imagem mais leve para empacotar a aplicação compilada para produção, um processo que será executado no próximo passo.

      Passo 5 — Excluindo Ferramentas de Compilação em uma Compilação Multi-Stage

      Idealmente, as imagens que você executa em produção não devem ter nenhuma ferramenta de compilação instalada ou dependências redundantes para a execução da aplicação de produção. Você pode removê-las da imagem Docker final usando compilações multi-stage. Isso funciona através da construção do binário, ou em outros termos, a aplicação Go compilada, em um container intermediário, copiando-o em seguida para um container vazio que não tenha dependências desnecessárias.

      Comece criando outro arquivo chamado Dockerfile.multistage:

      • nano ~/mux-go-api/Dockerfile.multistage

      O que você vai adicionar aqui será familiar. Comece adicionando o mesmo código que está em Dockerfile.golang-alpine. Mas desta vez, adicione também uma segunda imagem onde você copiará o binário a partir da primeira imagem.

      ~/mux-go-api/Dockerfile.multistage

      FROM golang:1.10-alpine3.8 AS multistage
      
      RUN apk add --no-cache --update git
      
      WORKDIR /go/src/api
      COPY . .
      
      RUN go get -d -v 
        && go install -v 
        && go build
      
      ##
      
      FROM alpine:3.8
      COPY --from=multistage /go/bin/api /go/bin/
      EXPOSE 3000
      CMD ["/go/bin/api"]
      

      Salve e feche o arquivo. Aqui você tem dois comandos FROM. O primeiro é idêntico ao Dockerfile.golang-alpine, exceto por ter um AS multistage adicional no comando FROM. Isto lhe dará um nome de multistage, que você irá referenciar na parte inferior do arquivo Dockerfile.multistage. No segundo comando FROM, você pegará uma imagem base alpine e copiará para dentro dela usando o COPY, a aplicação Go compilada da imagem multiestage. Esse processo reduzirá ainda mais o tamanho da imagem final, tornando-a pronta para produção.

      Execute a compilação com o seguinte comando:

      • docker build -f Dockerfile.multistage -t prod .

      Verifique o tamanho da imagem agora, depois de usar uma compilação multi-stage.

      Você encontrará duas novas imagens em vez de apenas uma:

      Output

      REPOSITORY TAG IMAGE ID CREATED SIZE prod latest 82fc005abc40 38 seconds ago 11.3MB <none> <none> d7855c8f8280 38 seconds ago 294MB . . .

      A imagem <none> é a imagem multistage construída com o comando FROM golang:1.10-alpine3.8 AS multistage. Ela é apenas um intermediário usado para construir e compilar a aplicação Go, enquanto a imagem prod neste contexto é a imagem final que contém apenas a aplicação Go compilada.

      A partir dos 744MB iniciais, você reduziu o tamanho da imagem para aproximadamente 11,3MB. Manter o controle de uma imagem minúscula como esta e enviá-la pela rede para os servidores de produção será muito mais fácil do que com uma imagem de mais de 700MB e economizará recursos significativos a longo prazo.

      Conclusão

      Neste tutorial, você otimizou as imagens Docker para produção usando diferentes imagens Docker de base e uma imagem intermediária para compilar e construir o código. Dessa forma, você empacotou sua API de exemplo no menor tamanho possível. Você pode usar essas técnicas para melhorar a velocidade de compilação e deployment de suas aplicações Docker e de qualquer pipeline de CI/CD que você possa ter.

      Se você estiver interessado em aprender mais sobre como criar aplicações com o Docker, confira o nosso tutorial Como Construir uma Aplicação Node.js com o Docker. Para obter informações mais conceituais sobre como otimizar containers, consulte Building Optimized Containers for Kubernetes.



      Source link