O que é Docker?

Com a crescente demanda por soluções ágeis, escaláveis e portáteis no desenvolvimento de software, o Docker tem se destacado como uma poderosa ferramenta que revolucionou a maneira como aplicações são construídas, distribuídas e executadas.

Baseado na ideia de automatizar a implantação de aplicações por meio de contêineres, o Docker tem ganhado popularidade e notoriedade na comunidade de desenvolvimento devido a sua versatilidade, agilidade e eficiência.

Mas afinal, o que é Docker, para que ele serve e como funciona na prática? Neste artigo, você encontrará a resposta para cada uma dessas perguntas. Vamos começar?

1 – O que é Docker e para que serve?

O Docker é uma plataforma de código aberto que permite automatizar o empacotamento, a distribuição e a execução de aplicações em containers. Um container é uma unidade leve, portátil e autossuficiente que contém tudo o que uma aplicação precisa para funcionar: código, bibliotecas, dependências, variáveis de ambiente e arquivos de configuração.

Diferente das tradicionais máquinas virtuais, que emulam sistemas operacionais inteiros, os containers compartilham o núcleo (kernel) do sistema operacional do host, sendo muito mais leves e rápidos.

O Docker permite criar ambientes isolados que garantem que uma aplicação funcione da mesma forma em qualquer lugar — seja em um ambiente de desenvolvimento, em servidores de teste ou em ambientes de produção.

Em suma, o Docker serve para:

  • Facilitar a criação de ambientes consistentes para desenvolvimento, testes e produção;
  • Simplificar o processo de distribuição e implantação de software;
  • Isolar aplicações e serviços;
  • Aumentar a escalabilidade e a portabilidade dos sistemas.

1.1 – Principais características do Docker

As principais características dessa ferramenta incluem:

  • Portabilidade: um container pode ser executado em qualquer lugar que tenha o Docker instalado (Windows, Linux, macOS, servidores em nuvem, etc.).
  • Leveza: os containers utilizam menos recursos que máquinas virtuais, pois compartilham o mesmo kernel do sistema operacional.
  • Isolamento: cada container roda de forma isolada, evitando conflitos entre aplicações e versões de bibliotecas.
  • Rapidez na inicialização: containers iniciam quase instantaneamente.
  • Reprodutibilidade: através dos arquivos Dockerfile, é possível versionar e reproduzir exatamente o mesmo ambiente em diferentes máquinas.
  • Escalabilidade: a integração com ferramentas como Kubernetes, o que agiliza e facilita a escalabilidade de aplicações em ambientes distribuídos.

2 – Como surgiu o Docker?

A ideia de isolamento de processos e contêineres não é nova, existindo conceitos similares há décadas, desde os antigos sistemas Unix (como LXC). No entanto, o Docker popularizou e simplificou significativamente o uso de contêineres, tornando-os acessíveis a um público muito mais amplo.

No ano de 2010, o Docker nasceu, originalmente, para uso interno da empresa de plataforma como serviço (PaaS) DotCloud (que posteriormente mudou seu nome para Docker Inc.), fundada por Solomon Hykes na França.

Foi em março de 2013 que o Docker foi lançado ao público como um projeto de código aberto. Sua facilidade de uso, a vasta comunidade que se formou ao redor e a solução eficaz para os desafios de implantação rapidamente impulsionaram sua adoção em todo o mundo.

A visão por trás do Docker era fornecer uma maneira padronizada e portátil de empacotar e executar aplicações, independentemente da infraestrutura subjacente. Essa abordagem resolveu muitos dos problemas enfrentados por desenvolvedores e equipes de operações, como inconsistências de ambiente, dificuldades de implantação e lentidão no ciclo de desenvolvimento.

3 – Como instalar o Docker?

A instalação do Docker varia conforme o sistema operacional. Abaixo, vamos ver os passos básicos de instalação para os principais sistemas:

3.1 – Windows e macOS

  1. Acesse o site oficial clicando aqui.
  2. Baixe a versão Docker Desktop para o seu sistema.
  3. Siga as etapas do assistente de instalação.
  4. Após instalado, abra o Docker Desktop e aguarde a inicialização do serviço.

3.2 Linux (exemplo para sistemas Ubuntu):

No terminal do Linux, execute os seguintes comandos.

sudo apt update
sudo apt install docker.io -y
sudo systemctl enable docker
sudo systemctl start docker

Com os passos acima, você conseguirá instalar o Docker de forma rápida e fácil em sistemas operacionais Linux. Mas, caso seja necessário, na página oficial do Docker, neste link aqui, você encontra tutoriais mais detalhados, inclusive para outras distribuições Linux além do Ubuntu.

4 – Utilizando o Docker na prática

Para melhorar seu entendimento de Docker vamos elaborar um exemplo simples e prático que lhe ajudará a compreender o funcionamento da ferramenta. Para começar, vamos verificar a versão instalada em seu sistema, executando o comando abaixo no terminal:

docker --version

Esse comando irá retornar a versão instalada em seu sistema, confirmando que as etapas executadas no item anterior foram bem sucedidas.

Agora vamos executar um servidor web (por exemplo, Nginx), com o seguinte comando:

docker run -d -p 8080:80 nginx

Acesse http://localhost:8080 e você verá a página padrão do Nginx rodando em um container.

4.1 – Criando uma aplicação Node.js

Para este exemplo vamos criar uma simples aplicação em Node.js que apresentará uma simples mensagem na tela do usuário. A estrutura do nosso projeto será a seguinte::

meu-app-node/
├── app.js
├── package.json
└── Dockerfile

Vamos criar o arquivo app.js:

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

app.get('/', (req, res) => {
  res.send('Olá, esta é uma aplicação Node.js rodando em um container Docker!');
});

app.listen(port, () => {
  console.log(`Servidor rodando em http://localhost:${port}`);
});

O próximo arquivo que criaremos é o package.json:

{
  "name": "meu-app-node",
  "version": "1.0.0",
  "main": "app.js",
  "scripts": {
    "start": "node app.js"
  },
  "dependencies": {
    "express": "^4.18.2"
  }
}

Por fim, vamos criar nosso Dockerfile:

# Usa uma imagem oficial do Node.js
FROM node:18

# Cria diretório da aplicação
WORKDIR /app

# Copia arquivos para o container
COPY package*.json ./
RUN npm install

COPY . .

# Expõe a porta 3000
EXPOSE 3000

# Comando para iniciar a aplicação
CMD ["npm", "start"]

4.2 – Executando o container

No seu terminal, navegue até a pasta onde estão os arquivos do seu projeto Node.js e execute o seguinte comando para construir a imagem Docker:

docker build -t meu-app-node .

Agora, vamos executar o container:

docker run -d -p 3000:3000 meu-app-node

Abra seu navegador web e acesse http://localhost:3000

Ao acessar esse endereço você visualizará essa mensagem na tela: “Olá, esta é uma aplicação Node.js rodando em um container Docker!”

Veja como é simples executar uma aplicação Node.js a partir de um container Docker. E o mais interessante de tudo, é que podemos usufruir dos recursos oferecidos pelo Docker para praticamente qualquer linguagem ou tipo de aplicação, mostrando a versatilidade dessa ferramenta e o grande número de possibilidades que temos com ela.

Conclusão

O Docker é uma ferramenta poderosa que transformou o modo como desenvolvedores e equipes de operações criam, testam e implantam aplicações. Com ele, é possível garantir ambientes consistentes, escaláveis e eficientes, otimizando processos de desenvolvimento e entrega contínua.

Se você ainda não experimentou, vale a pena começar — o Docker pode ser um divisor de águas no seu fluxo de trabalho, aumentando a sua produtividade e a qualidade de suas entregas.

Espero que este conteúdo seja útil de alguma forma para você. Se gostou do conteúdo, compartilhe com seus amigos e aproveite para acessar os outros artigos deste site — tem muito mais esperando por você!

O que é DevOps?

Em um cenário cada vez mais dinâmico e competitivo, empresas de tecnologia precisam entregar software com mais rapidez, qualidade e segurança. Nesse contexto, a cultura DevOps surge como uma resposta eficiente, promovendo integração entre equipes, automação de processos e melhoria contínua.

Mais do que uma prática técnica, o DevOps representa uma mudança de mentalidade, onde desenvolvimento e operações deixam de atuar de forma isolada para colaborar ativamente em todas as etapas do ciclo de vida de uma aplicação.

Neste artigo, vamos conhecer o que é DevOps, suas principais características e como colocá-lo em prática. Vamos começar?

1 – O que é DevOps?

DevOps é um conjunto de práticas que busca integrar as equipes de desenvolvimento de software (Dev) e operações de TI (Ops), com o objetivo de que trabalhem juntas de forma mais eficiente e colaborativa durante todo o ciclo de vida de um software, desde a concepção até a operação e manutenção. Em vez de equipes separadas, o DevOps promove uma mentalidade de responsabilidade compartilhada e comunicação contínua.

Mais do que ferramentas e processos, o DevOps é uma mudança cultural dentro das empresas de tecnologia — onde as barreiras entre desenvolvimento e operações são quebradas, promovendo integração, automação e melhoria contínua.

A cultura DevOps é uma abordagem que melhora a colaboração entre equipes, acelera o ciclo de entrega de software, aumenta a qualidade dos sistemas e garante maior confiabilidade nas aplicações.

1.1 – Principais características da cultura DevOps

Colaboração e comunicação entre equipes: este é o cerne do DevOps. As equipes de desenvolvimento e operações trabalham juntas desde o planejamento até a entrega e manutenção do software. Isso significa trabalho colaborativo, comunicação aberta, feedback constante, um senso de pertencimento a um objetivo comum e o compartilhamento de informações, objetivos e responsabilidades.

Automação de processos: a cultura DevOps proporciona a automação de tarefas repetitivas e manuais como testes, integração, deploy e monitoramento. A automação acelera os processos, reduz erros e libera as equipes para se concentrarem em tarefas mais estratégicas.

– Integração Contínua (CI) e Entrega Contínua (CD): o objetivo é entregar software de forma rápida, frequente e confiável. Isso é alcançado através de uma pipeline de integração e entrega contínua (CI/CD) responsável por automatizar as etapas de construção, testes e implantação do software.

– Infraestrutura como Código (IaC): a infraestrutura de TI (servidores, redes, armazenamento, etc.) é gerenciada e provisionada usando código, da mesma forma que o software. Isso permite versionamento, automação e repetibilidade na criação e gerenciamento da infraestrutura.

– Monitoramento e feedback contínuo: o monitoramento constante do desempenho de software e infraestrutura é essencial para identificar problemas rapidamente e garantir a estabilidade do sistema. O feedback obtido do monitoramento e das experiências dos usuários serve como fomento para melhorar continuamente o software e os processos.

Responsabilidade compartilhada: todos são responsáveis pelo sucesso do software — da qualidade do código à estabilidade em produção.

Cultura de aprendizado e experimentação: o DevOps incentiva uma cultura onde as equipes se sentem seguras para experimentar, aprender com os erros e implementar melhorias contínuas. A análise de falhas é vista como uma oportunidade de aprendizado, e não de culpabilização de integrantes da equipe.

2 – Como aplicar a cultura DevOps na prática

A aplicação da cultura DevOps traz diversos benefícios para empresa e departamentos de tecnologia da informação, dentre os quais podemos citar: entregas mais rápidas e frequentes; menor taxa de falhas em produção; maior estabilidade e performance dos sistemas; melhor alinhamento entre negócio e tecnologia; ambiente de trabalho mais colaborativo.

A complexidade de implementação da cultura DevOps está diretamente relacionada com fatores como tamanho da empresa ou departamento, nível de maturidade dos processos, experiências prévias da equipe, abertura para mudanças, entre outros.

2.1 – Etapas da implementação

O processo de implementação é composto pelas etapas a seguir:

1 – Comece pela Cultura

– A tecnologia é um facilitador, mas a mudança cultural é fundamental. Invista em treinamento e conscientização para que as equipes entendam os princípios do DevOps e se sintam engajadas na mudança.

2 – Promova a colaboração

– Integre as equipes de Dev e Ops em squads distintas.

– Use ferramentas de comunicação eficientes (como Slack, Teams, Jira, etc.).

– Realize cerimônias conjuntas (como daily meetings, retrospectives e plannings).

3- Implemente CI/CD

– Use ferramentas de CI/CD como Jenkins, GitHub Actions, GitLab CI, CircleCI, Azure DevOps, etc.

– Identifique as tarefas manuais e repetitivas que podem ser automatizadas. Comece com a automação de processos básicos de build, testes e deploy e, progressivamente, avance para os mais complexos.

4 – Automatize infraestrutura (IaC)

– Utilize ferramentas como Terraform, Ansible, ou AWS CloudFormation para criar e gerenciar infraestruturas de forma automatizada e versionada.

5 – Monitore tudo

– Utilize ferramentas como Prometheus, Grafana, New Relic ou Datadog para monitorar em tempo real o desempenho de serviços e aplicações. Também configure alertas para detectar problemas rapidamente.

6 – Adote práticas de observabilidade

– Centralize logs (ex: ELK Stack), use dashboards e métricas para entender o comportamento da aplicação.

7 – Fomente a cultura de aprendizado:

– Realize post-mortems sem culpabilizar ninguém.

– Compartilhe boas práticas e incentive sua aplicação pela equipe.

– Crie um ciclo de feedback. Estabeleça canais para coletar feedback dos usuários e das equipes de operações. Use esse feedback para melhorar continuamente o software e os processos.

8 – Mensure o Progresso

– Defina métricas para acompanhar o sucesso da sua implementação de DevOps. Isso pode incluir a frequência de implantações, o tempo de resposta a incidentes, a taxa de erros e a satisfação do cliente.

Conclusão

A adoção da cultura DevOps vai além da simples aplicação de ferramentas — ela requer transformação organizacional, comprometimento das equipes e uma postura contínua de aprendizado e adaptação.

Ao unir pessoas, processos e tecnologia em torno de um objetivo comum, o DevOps impulsiona a inovação, aumenta a qualidade das entregas e promove ambientes de trabalho mais integrados e eficientes.

Empresas que investem na implementação da cultura DevOps estão mais preparadas para responder rapidamente às mudanças do mercado e entregar valor real aos seus clientes.

Espero que este conteúdo seja útil de alguma forma para você. Se gostou do conteúdo, compartilhe com seus amigos e aproveite para acessar os outros artigos deste site.

O que é Apache Kafka?

Com o avanço da tecnologia e o crescimento exponencial do volume de dados gerados diariamente, o Apache Kafka tornou-se em uma ferramenta essencial para lidar com esses grandes fluxos de dados de forma rápida, eficiente e escalável.

O Apache Kafka é uma das principais plataformas de streaming de eventos em tempo real da atualidade. Utilizado por grandes empresas ao redor do mundo, o Kafka permite a coleta, armazenamento, processamento e distribuição de grandes quantidades de dados, garantindo alta performance.

Neste texto, vamos explorar o que é o Apache Kafka, como ele funciona, e também demonstrar seu uso prático com um exemplo simples e didático em Python. Vamos começar?

1 – O que é o Apache Kafka?

O Apache Kafka é uma plataforma open source de streaming de eventos usada para coletar, armazenar, processar e distribuir grandes volumes de dados em tempo real. Ele é utilizado em aplicações que precisam lidar com fluxos contínuos e volumosos de informações, como logs de sistemas, monitoramento de sensores, processamento de pagamentos, atualizações de estoques e muito mais.

O Kafka foi lançado em 2011, como resultado do trabalho de um grupo de desenvolvedores do LinkedIn. Inicialmente, eles criaram a ferramenta para uso interno da própria empresa. O objetivo era desenvolver uma ferramenta para o processamento diário de grandes volumes de mensagens. Em sua primeira versão, o Kafka conseguia processar até 1,4 trilhão de mensagens por dia, um número expressivo de dados.

O código desenvolvido por Jun Rao, Jay Kreps e Neha Narkhede se tornou público ainda em 2011 e desde então começou a popularizar-se entre os desenvolvedores do mundo todo. Três anos depois, em 2014, os desenvolvedores Jun, Jay e Neha abriram uma empresa chamada Confluent, que fornece uma versão comercial do Apache Kafka.

É válido lembrar que, mesmo que existam versões comerciais do Kafka, ele é um projeto de código aberto. Inclusive, a plataforma foi doada pelos seus criadores à Apache Software Foundation (dai o nome Apacha Kafka), que a mantém até os dias atuais, incorporando novas funcionalidades e melhorias ao Kafka.

2 – Como funciona o Kafka?

O Kafka funciona como uma plataforma de mensagens, utilizando o modelo de Publicação/Assinatura (Publisher/Subscriber ou Pub/Sub). Nesse modelo, temos um produtor de informações (ou mensagens) de um lado, e um receptor do outro lado. Entre eles fica um servidor que atua como um intermediador entre as partes. Observe o esquema abaixo:

Representação gráfica da estrutura do apache kafka.
Fonte: o autor

Vamos imaginar uma empresa de entregas que recebe pedidos de um e-commerce e precisa faturá-los antes de distribuí-los para os seus entregadores. No Kafka, isso funciona assim:

  1. Produtores (Producers) → São os geradores ou remetentes dos dados. Em nosso exemplo, trata-se do sistema de e-commerce enviando os pedidos de seus clientes.
  2. Tópicos (Topics) → São as “caixas de correio” onde os dados são organizados (exemplo: um tópico chamado pedidos armazena todas as informações de novos pedidos).
  3. Corretores (Brokers) → São os servidores do Kafka que armazenam os dados e garantem sua entrega aos consumidores (consumers).
  4. Consumidores (Consumers) → São os destinatários ou receptores dos dados. Em nosso exemplo poderia ser um sistema de faturamento consumindo os pedidos para gerar notas fiscais.

Com base no exemplo acima, podemos entender que sistemas de streaming de eventos do tipo Pub/Sub possuem um emissor (Publisher) de mensagens, responsável por transmitir os dados de um ponto a outro, e um consumidor (Subscriber), que lê essas mensagens.

Os Publishers, por sua vez, não direcionam as mensagens diretamente para seus receptores. Ao invés disso, eles agrupam suas mensagens em tópicos ou filas em um broker, que é um servidor que possui a função de centralizar essas mensagens publicadas. O receptor (Subscriber) “assina” o tópico específico para receber as mensagens agrupadas.

Sempre que um Subscriber ler uma mensagem em um tópico específico, ele deverá fazer a confirmação dessa leitura, através de um processo chamado commit.

2.1 Commits

No Kafka, o processo de confirmação de leitura das mensagens é conhecido como “commit”. Ele é um processo crucial para garantir a entrega confiável dos dados aos consumidores.

Para entender esse processo devemos saber que o kafka utiliza o conceito de offsets. Cada mensagem publicada em um tópico recebe um identificador único e sequencial chamado offset, o qual representa a sua posição dentro da partição do tópico.

A confirmação de leitura (Commit) ocorrerá quando um consumidor processar uma mensagem. Esse consumidor irá informar ao Kafka o offset da última mensagem processada com sucesso. Por sua vez, o kafka irá marcar como lidas todas as mensagens até aquele offset informado. Isso evitará que, em um novo processamento de dados, as mensagens sejam lidas em duplicidade.

É importante também observar que existem dois tipos principais de confirmação de leitura:

  • Confirmação automática (auto-commit): o Kafka confirma os offsets automaticamente em intervalos regulares. É mais simples de configurar, mas pode levar à perda ou duplicação de dados em caso de falhas.
  • Confirmação manual (manual commit): o consumidor controla explicitamente quando os offsets são confirmados. Oferece maior controle e garante maior confiabilidade, porém exige mais código.

A confirmação de leitura garante que o sistema processe as mensagens exatamente uma vez (ou pelo menos uma vez, dependendo da configuração). Em caso de falhas, o consumidor pode retomar o processamento a partir do último offset confirmado, evitando a perda de dados.

Realizar a confirmação de leitura é fundamental para garantir a integridade e a consistência dos dados em sistemas que consomem dados de streaming de eventos.

3 – Exemplo prático

Agora que você entendeu o que é o Apache Kafka e como ele funciona, que tal ver um exemplo prático com código?

A ideia aqui é bem simples: vamos criar um produtor que enviará algumas mensagens para o Kafka com informações de vendas realizadas por alguns vendedores, e um consumidor que escuta esse tópico e imprime as mensagens recebidas.

Para isso, você vai precisar ter instalado na sua máquina:

  • Ter o Apache Kafka rodando localmente: você pode usar o Docker ou instalar manualmente. Eu recomendo que você utilize o Docker, pois, ele facilita muito o processo de instalação.
  • Ter o Python instalado na sua máquina e o gerenciador de pacotes pip;
  • Instalar a biblioteca kafka-python: no terminal do seu sistema operacional execute o comando pip install kafka-python.

Após instalar as ferramentas necessárias, inicie o container kafka e acesse-o com o comando docker exec -it kafka bash

Após acessar o kafka, vamos criar um tópico chamado comercial, com o seguinte comando: kafka-topics.sh --create --topic comercial --bootstrap-server localhost:9092

3.1 – Criando os códigos

Para nosso exemplo, vamos criar dois códigos: um producer e um consumer.

O primeiro arquivo que vamos criar é o producer.py, que será responsável por enviar 5 mensagens para nosso tópico do kafka:

from kafka import KafkaProducer
import json

# Cria um produtor Kafka conectado ao servidor local
producer = KafkaProducer(
    bootstrap_servers='localhost:9092',
    value_serializer=lambda v: json.dumps(v).encode('utf-8')
)

# Lista de mensagens para envio
mensagens = [
    {"vendaId": "50001", "vendedor": "ana.silva", "valor": 120.50, "formaPagamento": "PIX"},
    {"vendaId": "50002", "vendedor": "joao.souza", "valor": 80.00, "formaPagamento": "Crédito"},
    {"vendaId": "50003", "vendedor": "maria.lima", "valor": 230.90, "formaPagamento": "Débito"},
    {"vendaId": "50004", "vendedor": "carlos.pereira", "valor": 45.75, "formaPagamento": "Dinheiro"},
    {"vendaId": "50005", "vendedor": "lucas.almeida", "valor": 150.00, "formaPagamento": "PIX"}
]

# Envia cada mensagem e imprime confirmação personalizada
for msg in mensagens:
    future = producer.send('comercial', msg)
    result = future.get(timeout=10) 
    print(f"Venda {msg['vendaId']} enviada com sucesso!")

producer.flush()

Além do código do producer, vamos criar o arquivo consumer.py, que será responsável por ler nosso tópico de kafka:

from kafka import KafkaConsumer
import json

# Cria um consumidor Kafka que escuta o tópico 'transacoes'
consumer = KafkaConsumer(
    'transacoes',
    bootstrap_servers='localhost:9092',
    value_deserializer=lambda m: json.loads(m.decode('utf-8')),
    auto_offset_reset='earliest',  # Começa a ler do início do tópico
    group_id='meu-grupo'  # Grupo de consumidores
)

print("Aguardando mensagens...")
for mensagem in consumer:
    print(f"Mensagem recebida: {mensagem.value}")

Com esses dois códigos, conseguiremos ver o funcionamento do kafka na prática. Para começar vamos executar nosso producer.py. O resultado obtido será esse aqui:

Print das mensagens enviadas para o tópico de kafka.

Agora que as mensagens foram enviadas para o tópico do kafka, vamos executar nosso consumer.py. O resultado será esse aqui:

Print das mensagens consumidas do tópico de kafka.

Observe nesse simples exemplo que conseguimos simular o envio e consumo de algumas mensagens através do Kafka. Na prática, os sistemas que utilizam Kafka trafegam milhares ou milhões de mensagens por hora. Sem o uso de um sistema de streaming de eventos é praticamente impossível gerenciar tal volume de informação de forma eficiente. Por isso, aprender como o Kafka funciona é fundamental para profissionais e estudantes da área de TI.

Conclusão

O Apache Kafka é uma ferramenta poderosa e versátil para o processamento de dados em tempo real, oferecendo uma arquitetura robusta baseada no modelo de publicação e assinatura.

Sua capacidade de lidar com grandes volumes de mensagens de forma confiável o torna indispensável em cenários que exigem alta escalabilidade e desempenho. Através do exemplo prático apresentado, foi possível observar como produtores e consumidores interagem com tópicos no Kafka, evidenciando seu papel central em sistemas modernos de dados.

Para profissionais de tecnologia, dominar o funcionamento do Kafka é um diferencial competitivo relevante em um mercado cada vez mais orientado a dados.

Espero que este artigo seja útil de alguma forma para você. Em caso de dúvidas, sugestões ou reclamações, fique à vontade para entrar em contato.

Ah, e se você quiser conhecer mais sobre Arquitetura de Sistemas, não deixe de acessar a categoria que tenho dedicada ao assunto.