Criação de Imagens de Contêiner

Antes de prosseguirmos com a criação de imagens de Container, é essencial que você esteja preparado com todas as ferramentas necessárias para uma experiência de aprendizado completa e eficaz. Uma dessas ferramentas é o Docker Hub, uma plataforma que nos permite gerenciar e distribuir imagens de contêineres Docker.

2.1. Por que o Docker Hub?

O Docker Hub é uma registry de imagens Docker. Em termos simples, é como um repositório centralizado onde podemos buscar, armazenar e gerenciar imagens Docker. Durante nossas aulas, usaremos o Docker Hub para baixar, enviar e compartilhar imagens que serão essenciais para nossos exercícios práticos.

2.1.1. Instruções para Criação de Conta no Docker Hub

Acesse o Site: https://hub.docker.com. Vá para Docker Hub e clique em “Sign Up” no canto superior direito da página. Preencha seus Dados: Forneça um nome de usuário, endereço de e-mail e senha. Certifique-se de lembrar desses detalhes, pois você os usará frequentemente durante o curso. Verifique seu E-mail: Após o registro, você receberá um e-mail de confirmação. Clique no link fornecido para verificar sua conta.

Faça Login: Depois de confirmar seu e-mail, retorne ao Docker Hub e faça login com suas credenciais.

2.2. Introdução à Criação de Imagens de Contêiner

As imagens de contêiner desempenham um papel crucial no ecossistema do Kubernetes, pois fornecem o ambiente necessário para executar aplicativos isolados e independentes. Neste capítulo, aprenderemos como criar imagens de contêiner usando ferramentas como o Docker e o Podman, além de explorar a hospedagem dessas imagens em uma registry.

2.3. Criação de Imagens de Contêiner com Docker ou Podman

O processo de criação de imagens de contêiner envolve a definição de uma imagem base e a adição de camadas adicionais contendo o código, dependências e configurações do aplicativo. Vamos explorar o uso do Docker e do Podman para criar imagens.

2.3.1. Docker

O Docker é uma ferramenta amplamente utilizada para criar e gerenciar imagens de contêiner. Para criar uma imagem com o Docker, você precisará de um arquivo chamado Dockerfile ou Containerfile, que contém um conjunto de instruções para a construção da imagem.

Aqui está um exemplo de Dockerfile para criar uma imagem de um aplicativo Node.js:

FROM node:14
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm install
COPY . .
CMD [ "npm", "start" ]

Neste exemplo, estamos usando a imagem base node:14 do Docker Hub, definindo o diretório de trabalho, copiando os arquivos de configuração e dependências, instalando as dependências e configurando o comando para iniciar o aplicativo.

2.3.2. Podman

O Podman é uma alternativa ao Docker que oferece uma experiência semelhante para criação e execução de contêineres, mas sem a necessidade de um daemon em execução. O processo de criação de imagens com o Podman é semelhante ao Docker, mas usando um arquivo chamado Containerfile.

Aqui está um exemplo de Containerfile para criar uma imagem de um aplicativo Node.js com o Podman:

FROM docker.io/node:14
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm install
COPY . .
CMD [ "npm", "start" ]

Neste exemplo, estamos usando a mesma estrutura do Dockerfile, mas substituindo o comando FROM para obter a imagem do repositório do Docker Hub.

2.3.3. Instruções do Dockerfile/Containerfile

Os arquivos Dockerfile e Containerfile são usados para definir as etapas necessárias para construir uma imagem de contêiner. Esses arquivos consistem em uma série de instruções, cada uma executando uma tarefa específica durante o processo de construção da imagem. Vamos explorar algumas das instruções mais comuns:

• FROM: Essa instrução define a imagem base a ser usada para a construção da sua imagem. É a primeira instrução em um arquivo Dockerfile/Containerfile e é obrigatória. Por exemplo, FROM node:14 especifica que estamos usando a imagem base do Node.js versão 14.
• MAINTAINER: Define o autor do Dockerfile. Esta instrução está obsoleta e é recomendado usar a instrução LABEL para isso.

Exemplo: MAINTAINER nome@email.com

• WORKDIR: Essa instrução define o diretório de trabalho dentro do contêiner, onde serão executados comandos subsequentes. É recomendado definir um diretório de trabalho para organizar o código e os arquivos do aplicativo. Por exemplo, WORKDIR /app define o diretório de trabalho como /app.
• COPY e ADD: Essas instruções são usadas para copiar arquivos e diretórios do host para o contêiner. A instrução COPY copia arquivos e diretórios do host para o diretório de trabalho do contêiner, enquanto a instrução ADD é semelhante ao COPY, mas com suporte a recursos extras, como descompactação de arquivos. Por exemplo, COPY package.json package-lock.json ./ copia os arquivos package.json e package-lock.json do diretório atual do host para o diretório de trabalho do contêiner.
• RUN: Essa instrução executa um comando durante o processo de construção da imagem. É usada para executar tarefas, como instalação de dependências, compilação de código ou execução de scripts de configuração. Por exemplo, RUN npm install instala as dependências do aplicativo usando o gerenciador de pacotes npm.
• CMD e ENTRYPOINT: Essas instruções definem o comando padrão a ser executado quando o contêiner for iniciado. A instrução CMD especifica os argumentos do comando como uma matriz JSON, enquanto a instrução ENTRYPOINT define o comando como executável. Por exemplo, CMD [ "npm", "start" ] define o comando padrão para iniciar o aplicativo Node.js usando o npm.
• LABEL: Adiciona metadados à imagem, como a versão ou uma descrição.
• EXPOSE: Informa ao Docker que o contêiner escuta em uma porta de rede específica durante a execução.
• ENV: Define uma variável de ambiente.
• ARG: Define uma variável que os usuários podem passar na construção da imagem Docker.
• VOLUME: Cria um ponto de montagem para volumes.
• USER: A instrução USER no Dockerfile define qual usuário ou UID será usado para executar os comandos subsequentes no Dockerfile e também para executar o comando quando o contêiner for iniciado. Esta instrução é útil para garantir que os processos em um contêiner sejam executados com as permissões apropriadas.marconesns/modulo_k8s_II/tree/main/ec2_kubernetes_ansible/ec2
• ONBUILD: Adiciona um acionador que será executado em uma imagem derivada.
• STOPSIGNAL: Define o sinal do sistema que será enviado ao contêiner para sair.

Exemplo: STOPSIGNAL SIGTERM

• HEALTHCHECK: Informa ao Docker como testar o contêiner para verificar se ele ainda está funcionando.

Exemplo: HEALTHCHECK CMD curl –fail http://localhost/ || exit 1

• SHELL: Permite o uso de um shell diferente.

Exemplo: SHELL [“/bin/bash”, “-c”]

Essas são apenas algumas das instruções mais comuns usadas nos arquivos Dockerfile e Containerfile. Existem muitas outras instruções disponíveis, como EXPOSE para definir portas expostas pelo contêiner, ENV para definir variáveis de ambiente e ARG define uma variável que os usuários podem passar no tempo de compilação para o construtor com o comando docker build usando o sinalizador –build-arg <varname>=<value>.

Certifique-se de consultar a documentação oficial do Docker ou Podman para obter mais informações sobre todas as instruções disponíveis e suas opções de configuração.

2.4. Armazenamento de Imagens em uma Registry

Após criar suas imagens de contêiner, é útil armazená-las em uma registry para facilitar o compartilhamento e implantação em outros ambientes. Existem várias registries disponíveis, como o Docker Hub e o Quay.io.

2.4.1. Docker Hub

O Docker Hub é uma registry pública amplamente utilizada para armazenar imagens de contêiner. Ele permite que você faça o upload de suas imagens gratuitamente e compartilhe-as com outros desenvolvedores.

Aqui estão os passos básicos para fazer o upload de uma imagem para o Docker Hub:

2. Faça login na sua conta usando o comando docker login no terminal.

docker login docker.io

A saída algo como:

Username: *<nome-de-usuario>*
Password: *******
Login Succeeded!

3. Marque sua imagem usando o nome da sua conta no Docker Hub, por exemplo: docker.io/<nome-de-usuario>/minha-imagem:latest.

docker images

A saída de exmplo é:

REPOSITORY                 TAG         IMAGE ID      CREATED         SIZE
localhost/teste            1.0         793905676598  8 minutes ago   4.5 MB

docker images
docker tag 793905676598 docker.io/<nome-de-usuario>/minha-images:latest

4. Faça o upload da imagem para o Docker Hub usando o comando docker push <nome-de-usuario>/minha-imagem:latest.

docker images
docker push docker.io/<nome-de-usuario>/minha-images:latest

2.4.2. Outras Registries

Além do Docker Hub, existem outras registries disponíveis, como o Quay.io, que também oferece recursos avançados para hospedagem de imagens de contêiner. Os passos para fazer o upload de imagens para essas registries podem variar, mas geralmente seguem um processo semelhante ao do Docker Hub.

2.5. Pull de imagem de um registro privado

Você precisará seguir alguns passos. Vou guiá-lo por um processo geral para realizar essa tarefa:

2.5.1. Autenticação com o Registro Privado

A autenticação com um registro privado é um passo crucial ao puxar imagens do Kubernetes, especialmente quando essas imagens são armazenadas em repositórios que exigem autenticação. Os registros privados são usados para armazenar imagens Docker fora dos repositórios públicos, como o Docker Hub, e geralmente têm requisitos de segurança mais rigorosos.

A autenticação é necessária para garantir que apenas usuários autorizados tenham acesso às imagens armazenadas no registro privado. Isso é alcançado por meio de credenciais de autenticação, que podem ser nome de usuário/senha, tokens, chaves SSH ou outros métodos.

Aqui estão alguns detalhes adicionais sobre a autenticação com um registro privado:

Credenciais de Acesso:

Quando você cria uma conta em um registro privado, normalmente recebe credenciais de acesso que incluem um nome de usuário e uma senha ou um token. Essas credenciais são usadas para autenticar-se e obter permissão para puxar imagens do registro.

Segurança:

É importante tratar as credenciais de acesso com segurança. Não as compartilhe publicamente, nem as armazene em texto simples. O Kubernetes fornece recursos para armazenar essas credenciais de forma segura, como os segredos do Kubernetes.

Segredos do Kubernetes:

O Kubernetes oferece o recurso “Secret” (segredo) para armazenar informações sensíveis, como tokens de autenticação. Os segredos podem ser usados para autenticação em registros privados ao puxar imagens. Eles são codificados em base64 para proteger contra exposição acidental em arquivos de manifesto.

ImagePullSecrets:

No Kubernetes, o campo imagePullSecrets é usado para especificar os segredos que devem ser usados para autenticar-se em registros privados ao puxar imagens. Isso é incluído no manifesto do Pod.

Renovação de Credenciais:

Tokens de autenticação podem ter um período de validade. Portanto, é importante estar ciente de quando as credenciais expirarão e renová-las conforme necessário.

Serviços de Autenticação Alternativos:

Além de autenticação baseada em nome de usuário/senha, alguns registros privados permitem autenticação usando chaves SSH, tokens de serviço do Google Cloud Platform (GCP) e outros métodos.

Os detalhes específicos da autenticação podem variar com base no registro privado que você está usando. É uma boa prática revisar a documentação do registro privado ou plataforma de nuvem para obter instruções precisas sobre como configurar a autenticação corretamente.

2.5.2. Criar um Segredo no Kubernetes

O Kubernetes fornece um recurso chamado “Secret” (segredo) para armazenar credenciais sensíveis, como tokens de autenticação. Você deve criar um segredo que conterá as informações necessárias para autenticação com o registro privado.

Exemplo de criação de um segredo para um registro Docker:

kubectl create secret docker-registry nome-do-segredo \
   --docker-server=SEU_REGISTRO \
   --docker-username=SEU_USUÁRIO \
   --docker-password=SEU_PASSWORD \
   --docker-email=SEU_EMAIL

2.5.3. Usar o Segredo em um Manifesto de Pod

Quando você cria um Pod no Kubernetes, pode especificar o segredo que deseja usar para puxar a imagem do registro privado.

Exemplo de um manifesto de Pod que utiliza um segredo para puxar uma imagem do registro privado:

apiVersion: v1
kind: Pod
metadata:
  name: meu-pod
spec:
  containers:
    - name: meu-container
      image: SEU_REGISTRO/NOME_DA_IMAGEM:TAG
  imagePullSecrets:
    - name: nome-do-segredo

2.5.4. Aplicar o Manifesto do Pod

Depois de criar o manifesto do Pod com as informações corretas, você pode aplicá-lo ao Kubernetes usando o comando kubectl apply -f nome-do-arquivo.yaml.

Verificar o Pull da Imagem

Depois que o Pod é criado, o Kubernetes usará as credenciais do segredo para autenticar-se no registro privado e puxar a imagem. Você pode verificar o status do Pod usando o comando kubectl get pods.

Lembre-se de substituir os valores em maiúsculas (SEU_REGISTRO, SEU_USUÁRIO, SEU_PASSWORD, etc.) pelos valores reais correspondentes ao seu registro privado e às suas credenciais de autenticação.

Além disso, este processo pode variar dependendo do sistema de registro que você está usando e das políticas de segurança da sua organização. Certifique-se de seguir as práticas recomendadas de segurança ao lidar com credenciais de autenticação.

2.5.5. Casos de Uso de uma Registry Privada

Em algumas situações, você pode precisar de uma registry privada para hospedar suas imagens de contêiner, especialmente quando se trata de aplicativos confidenciais ou em um ambiente corporativo. Serviços de nuvem populares, como o Amazon Elastic Container Registry (ECR) e o Google Container Registry (GCR), oferecem registry privada como um serviço.