Docker para Desenvolvedores

Se você é um entusiasta da programação ou está iniciando sua jornada, certamente já sentiu falta de um material sobre Docker para Desenvolvedores.

Este artigo é mais do que uma introdução; é um convite para explorar os benefícios e as transformações que o Docker trouxe para o desenvolvimento de aplicações.

Ao mergulharmos nas águas dos contêineres, imagens e eficiência no desenvolvimento moderno, descubra como o Docker se tornou a ferramenta essencial para garantir consistência e agilidade em todas as fases do ciclo de vida do software. Vamos la!

O que é o Docker

Docker é uma plataforma de virtualização leve e eficiente que simplifica o desenvolvimento, implantação e execução de aplicações por meio de containers.

Containers são ambientes isolados que incluem todos os recursos necessários para executar uma aplicação, como bibliotecas, dependências e configurações, garantindo consistência entre ambientes de desenvolvimento e produção.

Utilizando tecnologias de virtualização a nível de sistema operacional, 👉 o Docker permite que desenvolvedores empacotem e distribuam suas aplicações de forma padronizada, facilitando a escalabilidade e a gestão de infraestrutura. Isso proporciona benefícios como portabilidade, eficiência no consumo de recursos e rapidez no deploy, tornando o Docker uma ferramenta essencial para a modernização e agilidade do ciclo de vida de desenvolvimento de software.

Historia do Docker

A criação do Docker não foi uma casualidade, mas sim o resultado de uma jornada intensa de muito trabalho. Em 2013, em São Francisco, a empresa Docker, Inc. fundada por Solomon Hykes lançou ao mundo uma ferramenta que mudaria como desenvolvemos software.

Solomon Hykes, nascido na França, liderou uma equipe de desenvolvedores com um background técnico diversificado. Entre eles estavam especialistas em sistemas distribuídos, virtualização e automação.

O Docker foi concebido como uma resposta direta à dor sentida por desenvolvedores ao lidar com a migração de aplicações entre diferentes ambientes. Ao incorporar tecnologias como o Linux Containers (LXC), os criadores do Docker conseguiram fornecer uma solução elegante para encapsular aplicações e suas dependências.

Antes do Docker, os desenvolvedores frequentemente enfrentavam o desafio de “Isso funciona na minha máquina, mas não no servidor” 😬. A ferramenta surgiu como um remédio para essa dor, permitindo que aplicações fossem empacotadas com todas as suas dependências, garantindo consistência em qualquer ambiente.

O que são Containers?

Em termos simples, um container é uma unidade leve e autossuficiente que pode executar uma aplicação e suas dependências de forma isolada. Diferente das máquinas virtuais, os containers compartilham o kernel do sistema operacional do host, resultando em maior eficiência e velocidade. Ao utilizar recursos como namespaces e cgroups do Linux, os containers conseguem criar ambientes isolados, proporcionando consistência em diferentes ambientes de execução.

Vantagens dos Containers

A popularidade dos containers reside nas vantagens que oferecem ao desenvolvimento de software. A portabilidade é uma delas; um container pode ser executado de maneira consistente em qualquer ambiente que suporte a tecnologia, eliminando a famosa frase “Na minha máquina funciona”.

Além disso, a escalabilidade é simplificada, permitindo que aplicações sejam rapidamente replicadas e dimensionadas conforme a demanda, sem a necessidade de configurar complexas infraestruturas.

O que são Imagens Docker?

As imagens Docker desempenham um papel crucial para os containers, sendo a espinha dorsal que permite aos desenvolvedores empacotar e distribuir suas aplicações com facilidade. 

Uma imagem Docker é um pacote que contém tudo o que é necessário para executar uma aplicação, incluindo o código, as bibliotecas, as dependências e as configurações 🤩.

Utilizando um formato padronizado, as imagens são construídas a partir de um arquivo chamado Dockerfile, que descreve passo a passo como a imagem deve ser configurada. Essa abordagem padronizada facilita a criação de ambientes de desenvolvimento consistentes e reproduzíveis.

Reusabilidade e Eficiência

A grande vantagem das imagens Docker é a capacidade de reutilização. Uma vez que uma imagem é construída, ela pode ser compartilhada através do Docker Hub ou outros registros, permitindo que outros desenvolvedores a utilizem em seus projetos.

Essa reusabilidade não apenas acelera o desenvolvimento, mas também garante que todos os membros da equipe estejam trabalhando em um ambiente idêntico, evitando inconsistências e surpresas desagradáveis durante um deploy.

Implantação e Escalabilidade

Ao criar uma aplicação, os desenvolvedores podem pensar nas imagens Docker como fotografias do ambiente de execução.

Além disso, quando combinadas com orquestradores de containers como o Kubernetes, as imagens Docker facilitam o scaling, permitindo que aplicações se expandam ou se contraiam conforme a demanda, sem a necessidade de configurações complexas.

O que é Dockerfile?

No universo do Docker, o Dockerfile é uma peça-chave que permite aos desenvolvedores criar imagens personalizadas de containers de forma eficiente.

Definição e Funcionamento

Um Dockerfile é um arquivo de script que contém um conjunto de instruções para a construção de uma imagem Docker específica.

Cada linha no Dockerfile representa uma etapa no processo de criação da imagem, desde a escolha da imagem base até a configuração das dependências e a definição do ambiente de execução. Essa abordagem baseada em scripts proporciona consistência, reprodutibilidade e facilidade na criação de ambientes isolados para as aplicações.

Estrutura e Instruções Básicas

A estrutura de um Dockerfile é direta, composta por uma série de instruções que são executadas sequencialmente. Inicia-se com a escolha de uma imagem base usando a instrução FROM, seguida por comandos para instalação de dependências (RUN), definição de variáveis de ambiente (ENV), exposição de portas (EXPOSE), entre outras.

Cada instrução contribui para a configuração específica da imagem, garantindo que a aplicação seja executada da maneira desejada.

👉 Exemplo de um Dockerfile de uma aplicação React:

# Usando uma imagem oficial do Node.js como base
FROM node:14-alpine

# Definindo o diretório de trabalho dentro do contêiner
WORKDIR /app

# Copiando os arquivos de package.json e package-lock.json para o diretório de trabalho
COPY package*.json ./
RUN npm install --silent
RUN npm install react-scripts -g --silent

# Copiando todos os arquivos do diretório atual para o diretório de trabalho
COPY . .

# Expondo a porta 3000, que é a porta padrão usada pelo servidor de desenvolvimento do React
EXPOSE 3000

# Comando para iniciar a aplicação quando o contêiner for executado
CMD ["npm", "start"]

Explicando o que cada linha faz:

Vantagens e Personalização

A principal vantagem do Dockerfile é a capacidade de personalizar imagens de containers conforme as necessidades do desenvolvedor ou da aplicação. 🤓

Ao criar um Dockerfile, os desenvolvedores podem automatizar o processo de construção de imagens, tornando-o repetível e fácil de entender. Essa personalização não apenas facilita a criação de ambientes consistentes, mas também acelera o desenvolvimento, permitindo que as equipes compartilhem e repliquem configurações de forma eficiente.

Integração e Melhores Práticas

Para otimizar o uso do Dockerfile, é fundamental incorporar boas práticas, como:

• minimizar o número de camadas na imagem
• ordenar as instruções para melhorar a eficiência do cache
• remover arquivos temporários após a execução dos comandos.

O que é Docker Compose?

O Docker Compose é uma ferramenta que permite definir e gerenciar configurações multi-container de forma declarativa, usando um arquivo YAML.

Sua principal função é fornecer uma maneira eficiente de definir, executar e escalar aplicativos compostos por vários serviços, garantindo que todos os containers interajam de maneira harmoniosa.

Ao invés de lidar com diversos comandos individuais do Docker, o Docker Compose consolida todas as configurações em um único arquivo, simplificando a gestão de aplicações complexas.

Estrutura e Configuração

O Docker Compose utiliza um arquivo chamado docker-compose.yml, que descreve os serviços, redes e volumes necessários para a aplicação. Nesse arquivo, os desenvolvedores podem definir parâmetros como imagens do container, portas expostas, variáveis de ambiente e relações entre os serviços.

A estrutura clara e legível do YAML torna o arquivo de composição acessível, permitindo que os desenvolvedores visualizem e modifiquem facilmente as configurações do aplicativo.

Exemplo de docker-compose.yml de uma aplicação Go que também levanta um serviço de banco de dados Mongo:

version: '3'

services:
  # Serviço da aplicação Go
  app:
    image: golang:1.17-alpine
    container_name: minha-aplicacao-go
    working_dir: /go/src/app
    volumes:
      - .:/go/src/app
    ports:
      - "8080:8080"
    command: go run main.go

  # Serviço do banco de dados MongoDB
  mongo:
    image: mongo:latest
    container_name: meu-mongodb
    ports:
      - "27017:27017"
    environment:
      MONGO_INITDB_ROOT_USERNAME: usuario
      MONGO_INITDB_ROOT_PASSWORD: senha
      MONGO_INITDB_DATABASE: minha-base-de-dados

Explicando o que cada linha do arquivo acima faz:

Como o Docker funciona

O processo de criação de containers no Docker começa com a definição de um Dockerfile. Este arquivo contém as instruções para configurar um ambiente específico, incluindo a escolha da imagem base, a instalação de dependências e a configuração do ambiente de execução.

O Dockerfile serve como um guia, permitindo que desenvolvedores descrevam o ambiente desejado de forma declarativa.

Ao executar o comando docker build, o Docker utiliza o Dockerfile para construir uma imagem. Essa imagem é uma fotografia autossuficiente que contém a aplicação e todas as suas dependências. O processo é eficiente e rápido devido à tecnologia de camadas, que aproveita imagens existentes para evitar a duplicação de recursos durante a construção.

Isolamento e Eficiência

Uma vez que a imagem é criada, ela pode ser transformada em um container em execução com o comando docker run. Os containers Docker oferecem isolamento eficiente, compartilhando o kernel do sistema operacional do host, mas mantendo processos, redes e sistemas de arquivos independentes.

👉 Isso resulta em uma execução mais leve e eficiente em comparação com máquinas virtuais tradicionais.

Os containers Docker também aproveitam tecnologias do kernel do Linux, como namespaces e cgroups, para criar ambientes isolados. Isso significa que processos em um container não interfere com os processos em outros containers ou no host, proporcionando consistência e previsibilidade.

Orquestração e Escalabilidade

Para gerenciar aplicações compostas por vários containers, o Docker permite a integração com ferramentas de orquestração, como o Docker Compose, Docker Swarm e Kubernetes.

Essas ferramentas simplificam a implantação e o dimensionamento de aplicações, permitindo que desenvolvedores definam a configuração de toda a aplicação em um único arquivo.

Ao integrar-se a essas ferramentas, o Docker facilita a escalabilidade automática, possibilitando que aplicações se expandam ou contraiam conforme a demanda em produção. Isso é essencial para lidar com picos de tráfego e garantir o desempenho consistente de aplicações em ambientes dinâmicos.

Docker e Kubernetes: quais as diferenças?

Docker e Kubernetes são duas ferramentas fundamentais no universo da contêinerização e orquestração de aplicações. Embora estejam interligados, desempenham papéis distintos, complementando-se para oferecer uma solução completa. 

✅ Diferenças na Abordagem

• Docker: O Docker é uma plataforma de contêinerização que simplifica a criação, distribuição e execução de containers. Ele fornece uma maneira eficiente de encapsular aplicações e suas dependências em ambientes isolados, garantindo consistência e portabilidade.
• Kubernetes: Por outro lado, o Kubernetes é uma plataforma de orquestração que gerencia e escala automaticamente aplicações contêinerizadas. Ele se concentra em coordenar a implantação, atualização e expansão de containers em ambientes de produção.
  
  O Kubernetes oferece recursos avançados, como balanceamento de carga, descoberta de serviço e autoescalonamento, tornando-o ideal para ambientes complexos e de grande escala.

✅ Diferenças na Escala e Complexidade

• Docker: O Docker é adequado para desenvolvedores que buscam uma solução simples para containers. O Docker por si só é uma escolha madura para ambientes de desenvolvimento e pequenas deployments, onde a orquestração avançada não é essencial.
  
  Para ambientes produtivos, times de desenvolvimento precisam de alguma solução para coordenar e monitorar a execução dos containers.
• Kubernetes: Projetado para ambientes e aplicações complexas, o Kubernetes brilha em cenários de grande escala. Ele lida eficientemente com a orquestração de milhares de containers, garantindo alta disponibilidade e resiliência.

✅ Trabalhando com Docker e Kubernetes

• Uso Combinado: Muitas vezes, as equipes optam por usar o Docker para criar e gerenciar suas imagens de containers, e o Kubernetes para orquestrar esses containers em um ambiente de produção. Essa combinação oferece simplicidade no desenvolvimento e robustez na implantação.
• Docker Compose e Kubernetes: O Docker Compose é uma ferramenta que facilita a definição e a execução de aplicativos multi-container em ambientes de desenvolvimento. É comumente usado durante a fase de desenvolvimento local.
  
  Ao migrar para ambientes de produção, pode-se transicionar para a orquestração com Kubernetes, levando as dependências descritas no docker-compose.yml para o Kubernetes. Nesse momento, ferramentas como o Kompose podem ser de grande ajuda.
• Portabilidade: Uma das grandes vantagens de utilizar Docker e Kubernetes em conjunto é a portabilidade. Desenvolvedores podem construir suas aplicações em containers Docker localmente e, em seguida, subi-las em qualquer ambiente compatível com Kubernetes, seja em nuvem, local ou híbrido.

O Docker é pago?

Em sua essência, o Docker oferece uma base sólida de forma gratuita. Os recursos essenciais para criar, distribuir e executar containers estão disponíveis sem custos para desenvolvedores individuais e estudantes.

O Modelo Freemium do Docker

Entretanto, como muitas tecnologias modernas, o Docker adota um modelo freemium para atender às diversas necessidades de seus usuários.

Isso significa que, enquanto a versão básica é gratuita, há opções de planos pagos que oferecem recursos avançados e suporte especializado. Esses planos são projetados para atender às demandas de empresas e organizações com requisitos mais complexos.

Planos Pagos e Vantagens Adicionais

Ao optar por um plano pago do Docker, as organizações podem desfrutar de benefícios como suporte técnico prioritário, gerenciamento avançado de imagens e recursos de segurança adicionais.

Essas características são cruciais em ambientes de produção, onde a estabilidade, a segurança e o suporte técnico têm papel fundamental.

Comandos essenciais do Docker

Dominar os comandos mais úteis do Docker é crucial para desenvolvedores, pois oferece uma habilidade fundamental para resolver desafios diários.

Esses comandos proporcionam controle sobre a criação, execução e gestão de containers, permitindo a rápida resolução de problemas, desde a construção e implantação até a monitorização e depuração.

Resumimos abaixo os 10 comandos mais úteis do Docker para o dia-a-dia do desenvolvedor. Para navegar rapidamente entre eles, use os links abaixo:

docker run

O comando docker run é fundamental no ecossistema Docker, permitindo a execução de containers com base em imagens previamente construídas. Com essa instrução, os desenvolvedores podem transformar uma imagem Docker em um container funcional, pronto para executar sua aplicação.

docker run --name meu-container-web -p 8080:3000 minha-app-node

5d3d6472b54a1f3c36b41e5e5fb1a83d0a2d9e18f1a3d55c1e77b4e9e08a7e1a

docker build

O comando docker build também é crucial no processo de criação de imagens Docker personalizadas.

Ele permite que os desenvolvedores convertam suas configurações e dependências em uma imagem Docker, tornando-a pronta para ser usada na criação de containers.

docker build -t minha-imagem-app .

Successfully built 3a177a1ab3cd

docker ps

O comando docker ps permite aos desenvolvedores visualizar os containers em execução no sistema. Esse comando fornece uma visão instantânea do estado atual dos containers, exibindo informações essenciais como ID, nomes, portas expostas e tempo de execução.

docker ps

docker ps -a

CONTAINER ID   IMAGE        COMMAND            CREATED        STATUS       PORTS                   NAMES

4a3e8a285e12   nginx:latest "nginx -g 'daemon…"   5 minutes ago  Up 5 minutes   0.0.0.0:8080->80/tcp   web-server

docker exec

O comando docker exec permite que os desenvolvedores executem comandos dentro de um container em execução.

Essa funcionalidade é importante para interagir diretamente com aplicações em container, facilitando tarefas de manutenção, depuração e personalização em tempo real.

docker exec -it meu-container bash

docker start e docker stop

Os comandos docker start e docker stop são ferramentas essenciais no kit de comandos do Docker, permitindo que os desenvolvedores controlem o ciclo de vida dos containers. O docker start inicia um container previamente criado e parado, enquanto o `docker stop` interrompe a execução de um container em execução de maneira segura.

docker start meu-container

meu-container

docker stop meu-container

docker-compose up e docker-compose down

Os comandos docker-compose up e docker-compose down são o “docker start/stop”, porém no mundo do Docker-Compose.

Eles facilitam a execução e parada aplicações compostas por vários containers. O docker-compose up inicia os serviços definidos no arquivo docker-compose.yml, enquanto o docker-compose down encerra esses serviços de maneira ordenada.

docker-compose up

docker-compose down

Stopping meu-servico      ... done

Removing meu-servico      ... done

docker images

O comando docker images é a ferramenta para os desenvolvedores gerenciarem e visualizarem as imagens disponíveis em seus sistemas Docker.

Ele fornece uma lista clara e detalhada das imagens presentes localmente, facilitando o entendimento das versões, tamanhos e outras informações importantes.

docker images

REPOSITORY     TAG       IMAGE ID       CREATED         SIZE

nginx          latest    abcd1234efgh   2 days ago      132MB

my-app         v1.0      xyz5678ijkl   1 week ago      300MB

docker pull

O comando docker pull permite que os desenvolvedores baixem imagens de containers de repositórios remotos para uso local.

Essa ação é essencial para obter as últimas versões de imagens ou adquirir imagens específicas necessárias para o desenvolvimento.

docker pull nginx:latest

latest: Pulling from library/nginx

5c90d4a2d1a8: Pull complete

7c3d31739525: Pull complete

4a8b42f9ad87: Pull complete

Digest: sha256:abcd1234efghijklmnopqrstuvwxyz

Status: Downloaded newer image for nginx:latest

docker network

O comando docker network permite criar, gerenciar e visualizar redes para conectar containers.

Esse comando é importante para estabelecer a comunicação entre containers em diferentes serviços, proporcionando uma infraestrutura de rede adequada para a aplicação.

docker network ls

NETWORK ID     NAME            DRIVER    SCOPE

abcdef123456   bridge          bridge    local

ghijkl789012   host            host      local

mnopqr345678   my-network      bridge    local

docker logs

O comando docker logs possibilita os desenvolvedores visualizar os logs de saída de um container em execução.

Essa funcionalidade é essencial para monitorar e depurar aplicações, fornecendo insights sobre o comportamento interno dos containers.

docker logs meu-container

2023-01-15T10:30:00.000Z: Info: Aplicação iniciada com sucesso.

2023-01-15T10:35:00.000Z: Error: Conexão com o banco de dados falhou.

2023-01-15T10:40:00.000Z: Warn: Volume de solicitações HTTP aumentou.

Como rodar sua aplicação via Docker

Adaptar uma aplicação para rodar no Docker envolve alguns passos para tudo funcionar. Montamos um guia resumido dos principais pontos:

Dockerfile

• Crie um arquivo chamado Dockerfile no diretório do seu projeto.
• Defina a imagem base que melhor se adequa às necessidades da sua aplicação (por exemplo, uma imagem para Node.js, Python, etc.).
  
  O Docker Hub é um excelente lugar para você encontrar imagens base.

Configuração do Ambiente

• Liste todas as dependências e configurações necessárias para a sua aplicação no Dockerfile.
• Utilize camadas separadas para instalar dependências, copiar arquivos e configurar o ambiente.

Defina as portas expostas

• Especifique as portas que a aplicação utilizará no Dockerfile.
• Utilize a instrução EXPOSE para informar ao Docker quais portas devem ser disponibilizadas.

Especifique o comando que levanta sua app

• Especifique o comando que o Docker deve executar quando iniciar o container.
• Utilize a instrução CMD ou ENTRYPOINT no Dockerfile para definir o comando principal da aplicação.

Construa a imagem

• Execute o comando docker build no terminal, apontando para o diretório que contém o Dockerfile.

Rode o container

• Execute o container localmente com o comando docker run para garantir que tudo funcione conforme esperado.
• Se a sua app for Web, acesse a aplicação no navegador ou através de outras ferramentas para verificar sua funcionalidade.

😎 Sabemos que cada aplicação tem necessidades específicas, então certifique-se de ajustar os detalhes conforme necessário.

Para ajudar nesse processo, nós listamos alguns casos comuns de tecnologias específicas usando Docker. Vamos lá!

Docker com Python

Vamos criar uma aplicação Python simples que utiliza a calcula a sequência de Fibonacci para um número informado pelo usuário.

# fibonacci.py
def fibonacci(n):
    if n <= 0:
        return "Número inválido. Forneça um número inteiro positivo."
    elif n == 1:
        return [0]
    elif n == 2:
        return [0, 1]
    else:
        fib_sequence = [0, 1]
        while len(fib_sequence) < n:
            fib_sequence.append(fib_sequence[-1] + fib_sequence[-2])
        return fib_sequence

if __name__ == "__main__":
    number = int(input("Digite um número para calcular a sequência de Fibonacci: "))
    result = fibonacci(number)
    print(f"A sequência de Fibonacci para o número {number} é: {result}")

# Dockerfile
# Use a imagem oficial do Python como base
FROM python:3.9-slim

# Defina o diretório de trabalho dentro do contêiner
WORKDIR /app

# Copie o código Python para o diretório de trabalho
COPY fibonacci.py .

# Comando para executar a aplicação ao rodar o contêiner
CMD ["python", "fibonacci.py"]

docker build -t fibonacci-app .

   docker run -it fibonacci-app

Docker com Django

A aplicação Django abaixo é a mais simples possível: um “Olá Mundo”. Nesse exemplo mostramos a estrutura da app e seu Dockerfile:

from django.http import HttpResponse
from django.shortcuts import render

def hello_world(request):
    return HttpResponse("Olá Mundo")

from django.urls import path
from .views import hello_world

urlpatterns = [
    path('', hello_world, name='hello_world'),
]

...

INSTALLED_APPS = [
    ...
    'myapp',
]

...

Django==3.2.8

# Use a imagem oficial do Python como base
FROM python:3.9

# Define o diretório de trabalho dentro do contêiner
WORKDIR /app

# Copia os arquivos de requisitos para o diretório de trabalho
COPY requirements.txt .

# Instala as dependências usando o pip
RUN pip install --no-cache-dir -r requirements.txt

# Copia todos os arquivos do diretório atual para o diretório de trabalho
COPY . .

# Expõe a porta 8000 para acesso externo
EXPOSE 8000

# Comando para iniciar a aplicação quando o contêiner for executado
CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

docker build -t minha-aplicacao-django .

docker run -p 8000:8000 minha-aplicacao-django

Docker com Node.Js usando o Express

Aplicação “Olá Mundo”, dessa vez em Javascript usando o Express. Nesse exemplo mostramos a estrutura da app e seu Dockerfile:

{
  "name": "minha-aplicacao-node",
  "version": "1.0.0",
  "scripts": {
    "start": "node index.js"
  },
  "dependencies": {
    "express": "^4.17.1"
  }
}

const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => {
  res.send('Olá Mundo');
});

app.listen(port, () => {
  console.log(`Aplicação está rodando em http://localhost:${port}`);
});

# Use a imagem oficial do Node.js como base
FROM node:14-alpine

# Define o diretório de trabalho dentro do contêiner
WORKDIR /app

# Copia os arquivos necessários para o diretório de trabalho
COPY package.json .
COPY package-lock.json .

# Instala as dependências
RUN npm install

# Copia todos os arquivos do diretório atual para o diretório de trabalho
COPY . .

# Expõe a porta 3000 para acesso externo
EXPOSE 3000

# Comando para iniciar a aplicação quando o contêiner for executado
CMD ["npm", "start"]

docker build -t minha-aplicacao-node .

docker run -p 3000:3000 minha-aplicacao-node

Docker com  Go

API também no modelo “Olá Mundo”, usando Go com Fiber. Nesse exemplo mostramos a estrutura da app e seu Dockerfile:

package main

import (
  "github.com/gofiber/fiber/v2"
)

func main() {
  // Cria uma instância do Fiber
  app := fiber.New()

  // Define a rota principal
  app.Get("/", func(c *fiber.Ctx) error {
    // Retorna um JSON com a mensagem "Olá Mundo"
    return c.JSON(fiber.Map{"mensagem": "Olá Mundo"})
  })

  // Inicia o servidor na porta 3000
  app.Listen(":3000")
}

# Use a imagem oficial do Golang como base
FROM golang:1.18-alpine

# Define o diretório de trabalho dentro do contêiner
WORKDIR /app

# Copia todos os arquivos do diretório atual para o diretório de trabalho
COPY . .

# Constrói o executável da aplicação
RUN go build -o minha-aplicacao-go .

# Expõe a porta 3000 para acesso externo
EXPOSE 3000

# Comando para iniciar a aplicação quando o contêiner for executado
CMD ["./minha-aplicacao-go"]

docker build -t minha-aplicacao-go .

docker run -p 3000:3000 minha-aplicacao-go

Docker com  React

Pequena app também no modelo “Olá Mundo”, usando React. Nesse exemplo mostramos a estrutura da app e seu Dockerfile:

import React from 'react';

function App() {
  return (
    <div>
      <h1>Olá Mundo</h1>
    </div>
  );
}

export default App;

# Usando uma imagem oficial do Node.js como base
FROM node:14-alpine

# Definindo o diretório de trabalho dentro do contêiner
WORKDIR /app

# Copiando os arquivos de package.json e package-lock.json para o diretório de trabalho
COPY package*.json ./
RUN npm install --silent
RUN npm install react-scripts -g --silent

# Copiando todos os arquivos do diretório atual para o diretório de trabalho
COPY . .

# Expondo a porta 3000, que é a porta padrão usada pelo servidor de desenvolvimento do React
EXPOSE 3000

# Comando para iniciar a aplicação quando o contêiner for executado
CMD ["npm", "start"]

docker build -t minha-aplicacao-react .

docker run -p 3000:3000 minha-aplicacao-react

Docker com  Ruby on Rails

App Ruby on Rails com seu respectivo Dockerfile:

Rails.application.routes.draw do
  root 'welcome#index'
end

class WelcomeController < ApplicationController
  def index
    render plain: 'Olá Mundo'
  end
end

# Use a imagem oficial do Ruby como base
FROM ruby:3.2.2

# Define o diretório de trabalho dentro do contêiner
WORKDIR /app

# Instala as dependências do Rails
RUN gem install rails

# Copia os arquivos necessários para o diretório de trabalho
COPY . .

# Instala as dependências do projeto
RUN bundle install

# Comando para criar o banco de dados e iniciar a aplicação quando o contêiner for executado
CMD ["bin/rails", "db:create", "db:migrate", "bin/rails", "server", "-b", "0.0.0.0"]

docker build -t minha-aplicacao-rails .

docker run -p 3000:3000 minha-aplicacao-rails

Docker com  WordPress

App Wordpres com seu respectivo Dockerfile e Docker-Compose (para o banco de dados):

# Use a imagem oficial do WordPress como base
FROM wordpress:latest

# Define o diretório de trabalho dentro do contêiner
WORKDIR /var/www/html

# Copia todos os arquivos do diretório atual para o diretório de trabalho
COPY . .

# Expõe a porta 80 para acesso externo
EXPOSE 80

version: '3'

services:
  wordpress:
    build: .
    ports:
      - "8080:80"
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: exampleuser
      WORDPRESS_DB_PASSWORD: examplepass
      WORDPRESS_DB_NAME: exampledb
    volumes:
      - ./wp-content:/var/www/html/wp-content

  db:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: examplepass
      MYSQL_DATABASE: exampledb
      MYSQL_USER: exampleuser
      MYSQL_PASSWORD: examplepass
      MYSQL_RANDOM_ROOT_PASSWORD: '1'

docker-compose up -d

Como rodar seu banco de dados no Docker

Ao utilizar bancos de dados via Docker para apoiar o processo de desenvolvimento de uma aplicação no ambiente local, certas práticas são importantes.

Em primeiro lugar, é importante configurar volumes Docker para a persistência local de dados do banco, evitando a perda de informações entre reinicializações ou atualizações de containers, algo especialmente relevante no processo de desenvolvimento.

Outra dica importante é usar imagens oficiais do Docker Hub para o seu banco, mantendo sua imagem dentro dos padrões de desempenho e segurança criados pelo fornecedor do banco dados.

Mesmo em ambientes de desenvolvimento, manter sua base atualizada é importante, assim como garantir a segurança da imagem base do sistema operacional utilizada.

Docker com  Postgres

Aqui está um exemplo básico de um Dockerfile para rodar um banco de dados PostgreSQL. Este Dockerfile utiliza a imagem oficial do PostgreSQL disponível no Docker Hub.

# Use a imagem oficial do PostgreSQL como imagem base
FROM postgres:latest

# Defina variáveis de ambiente para configurar o PostgreSQL
ENV POSTGRES_DB=mydatabase \
    POSTGRES_USER=myuser \
    POSTGRES_PASSWORD=mypassword

# Exponha a porta padrão do PostgreSQL
EXPOSE 5432

# Comando padrão para iniciar o PostgreSQL
CMD ["postgres"]

docker build -t postgress .

docker run -p 5432:5432 postgress

Docker com  Mysql

Aqui está um exemplo básico de um Dockerfile para rodar um banco de dados MySQL. Este Dockerfile utiliza a imagem oficial do MySQL disponível no Docker Hub

# Use a imagem oficial do MySQL como imagem base
FROM mysql:latest

# Defina variáveis de ambiente para configurar o MySQL
ENV MYSQL_DATABASE=mydatabase \
    MYSQL_USER=myuser \
    MYSQL_PASSWORD=mypassword \
    MYSQL_ROOT_PASSWORD=myrootpassword

# Exponha a porta padrão do MySQL
EXPOSE 3306

# Comando padrão para iniciar o MySQL
CMD ["mysqld"]

docker build -t mysql .

docker run -p 3306:3306 mysql

Docker com  MongoDB

Aqui está um exemplo básico de um Dockerfile para rodar um banco de dados MongoDB. Este Dockerfile utiliza a imagem oficial do MongoDB disponível no Docker Hub

# Use a imagem oficial do MongoDB como imagem base
FROM mongo:latest

# Exponha a porta padrão do MongoDB
EXPOSE 27017

# Comando padrão para iniciar o MongoDB
CMD ["mongod"]

docker build -t mongodb .

docker run -p 27017:27017 mongodb

Como rodar Containers Docker em Produção

A adoção de containers em ambientes de produção tem experimentado um crescimento significativo nos últimos anos, impulsionada pela necessidade de agilidade, escalabilidade e consistência na implantação de aplicativos.

Empresas de diversos setores têm reconhecido os benefícios dos containers, que proporcionam isolamento, portabilidade e eficiência na execução de aplicações em diferentes ambientes. Essa tendência é particularmente evidente em arquiteturas de microsserviços, onde a modularidade e a flexibilidade dos containers facilitam o desenvolvimento, implantação e manutenção de serviços independentes.

Os principais provedores de computação em nuvem, como AWS, Azure e Google Cloud, têm respondido a essa demanda crescente ao oferecer serviços especializados para a orquestração e gerenciamento de containers.

Vamos listar abaixo algumas soluções que esses provedores de cloud oferece que permite a execução de containers Docker em produção. Vamos lá!

Rodando containers Docker na AWS

Não são poucos os serviços que a AWS oferece para rodar containers Docker, proporcionando flexibilidade e escalabilidade. Abaixo estão alguns dos principais serviços AWS para essa finalidade:

Amazon Elastic Container Service (ECS)

O ECS é um serviço de orquestração de containers que simplifica o gerenciamento, escalabilidade e implantação de containers Docker na AWS. Ele suporta tarefas e serviços, permitindo a execução de containers em clusters gerenciados.

Amazon Elastic Kubernetes Service (EKS)

O EKS é um serviço totalmente gerenciado que facilita a execução do Kubernetes na AWS. Ele oferece a capacidade de orquestrar containers Docker usando o Kubernetes, proporcionando uma abordagem mais flexível e amplamente adotada.

Amazon Fargate

O Fargate é um mecanismo de computação serverless para containers, permitindo que você execute containers sem gerenciar a infraestrutura subjacente. Ele pode ser utilizado tanto com o ECS quanto com o EKS, simplificando a execução de containers sem a necessidade de provisionar ou gerenciar servidores.

Amazon Lightsail

O Amazon Lightsail é um serviço simples que permite executar containers Docker em uma infraestrutura gerenciada. Ele oferece uma abordagem fácil e acessível para implantar e gerenciar containers.

AWS Batch

O AWS Batch é um serviço focado em cargas de trabalho de processamento em lote. Ele permite a execução de trabalhos usando containers Docker, gerenciando automaticamente a escalabilidade e a distribuição de tarefas em clusters de instâncias EC2

AWS App Runner

O AWS App Runner é um serviço que facilita a implantação, execução e escalabilidade de aplicações contêinerizadas sem a necessidade de gerenciar a infraestrutura subjacente. Ele suporta a execução de containers Docker em uma plataforma totalmente gerenciada.

Ufa! São muitas as opções para executar containers Docker na AWS, atendendo a diferentes necessidades e preferências de desenvolvimento e operações.

Rodando containers Docker na GCP

A Google Cloud Platform (GCP) também não fica de fora da festa, oferecendo diversos serviços que podem ser utilizados para rodar containers Docker.

Vamos ver alguns dos principais serviços da GCP para essa finalidade:

Google Kubernetes Engine (GKE)

O GKE é um serviço gerenciado do Kubernetes que simplifica a orquestração de containers Docker. Ele oferece um ambiente de execução Kubernetes totalmente gerenciado, permitindo a implantação, dimensionamento e gerenciamento eficiente de aplicativos em containers.

Cloud Run

O Cloud Run é um serviço completamente gerenciado para execução de containers sem servidor. Ele permite que você execute containers Docker em um ambiente sem estado, fornecendo escalabilidade automática com base na demanda.

Google Compute Engine (GCE)

O GCE oferece máquinas virtuais flexíveis que podem ser usadas para executar containers Docker. Embora não seja um serviço específico de containers, ele fornece uma infraestrutura robusta para execução de containers em VMs personalizadas.

Google Cloud Build

O Cloud Build é um serviço de CI/CD que permite automatizar a construção e implantação de containers Docker. Ele pode ser integrado a repositórios Git, como o Cloud Source Repositories.

Google Artifact Registry

O Artifact Registry é um serviço para armazenamento, gerenciamento e implantação de imagens de containers Docker. Ele fornece um repositório privado e seguro para suas imagens Docker. Pense nesse serviço como uma alternativa ao Docker Hub.

Rodando containers Docker na Azure

A Microsoft Azure também traz diversas soluções para rodar containers Docker. Abaixo listamos algumas delas:

Azure Kubernetes Service (AKS)

O AKS é um serviço gerenciado do Kubernetes que simplifica a orquestração de containers Docker. Ele oferece um ambiente de execução Kubernetes totalmente gerenciado, permitindo a implantação, dimensionamento e gerenciamento eficiente de aplicativos em containers.

Azure Container Instances (ACI)

O ACI é um serviço serverless que permite executar containers sem a necessidade de provisionar ou gerenciar máquinas virtuais. Ele fornece uma experiência leve e rápida para cargas de trabalho de containers.

Azure Container Registry (ACR)

ACR é um serviço para armazenamento, gerenciamento e implantação de imagens de containers Docker. Ele oferece um repositório privado e seguro para suas imagens Docker, integrando-se facilmente a outros serviços Azure.

Azure Service Fabric

O Azure Service Fabric é uma plataforma de computação distribuída que suporta a execução de microsserviços em containers Docker. Ele oferece escalabilidade e alta disponibilidade para aplicativos distribuídos.

Azure DevOps Services

O Azure DevOps Services inclui recursos para CI/CD de aplicativos em containers. Ele oferece integração com repositórios Git, pipelines de construção e implantação automatizada.

Azure Functions com Suporte a Containers

O Azure Functions oferece suporte a containers, permitindo que você execute funções serverless em containers Docker. Isso proporciona uma abordagem serverless para cargas de trabalho específicas.

Links Úteis

• Site oficial do Docker
• Modelo de precificação do Docker
• Site oficial do Kubernetes
• Kompose: ferramenta para converter arquivos docker-compose em resources do Kubernetes