Docker e Kubernetes

Docker e Kubernetes

• Docker e Kubernetes são tecnologias essenciais para modernizar e escalar aplicações de maneira eficiente e portátil.
• Docker fornece virtualização leve com contêineres, garantindo que aplicações rodem consistentemente em qualquer infraestrutura, independentemente do sistema operacional.
• Kubernetes atua como orquestrador de contêineres, automatizando a implantação, escalonamento e gerenciamento de aplicações distribuídas.
• A combinação do Docker com o Kubernetes oferece diversos benefícios, como maior eficiência operacional, automação de tarefas e resiliência contra falhas.
• Comandos do Docker como docker build, docker run e docker-compose facilitam a criação de imagens e a execução de contêineres , enquanto Kubernetes utiliza kubectl para gerenciar pods, deployments e serviços.
• Boas práticas como arquivos YAML e pipelines CI/CD garantem agilidade e segurança no desenvolvimento.

Docker

• O Docker é uma plataforma de conteinerização de código aberto que revolucionou o desenvolvimento, implantação e execução de aplicações.
• Ele empacota softwares com todas as suas dependências em unidades isoladas chamadas contêineres.
• Os contêineres Docker compartilham o kernel do sistema operacional, tornando a execução leve, rápida e eficiente em comparação com as máquinas virtuais.
• Desenvolvedores criam Dockerfiles para definir a configuração dos contêineres, o que gera imagens que podem ser armazenadas localmente ou em Docker Registries como o Docker Hub.
• O Docker Daemon gerencia a execução dos contêineres e interage com a Docker CLI/API.
• Cada contêiner é uma instância da imagem e pode acessar volumes para persistência de dados e redes para comunicação.
• Docker Network e Volumes garantem a conectividade e o armazenamento entre os contêineres.
• O Docker padroniza ambientes, reduzindo problemas de compatibilidade, agilizando a entrega contínua de software, e facilitando a manutenção de aplicações.
• A integração com ferramentas de orquestração como Kubernetes possibilita a escalabilidade automatizada.

Benefícios do Docker

• Docker proporciona portabilidade, eficiência e escalabilidade, permitindo que desenvolvedores criem ambientes isolados e reprodutíveis.
• Os contêineres Docker podem ser executados em qualquer ambiente compatível, garantindo flexibilidade e facilidade na migração entre sistemas operacionais e plataformas.

Exemplo Prático de Portabilidade

• Para criar e rodar um contêiner do Nginx:
  • docker pull nginx (baixa a imagem oficial do Nginx)
  • docker run -d -p 8080:80 nginx (executa o contêiner mapeando a porta 80 para 8080)
• O ambiente de desenvolvimento é idêntico ao de produção, evitando conflitos e garantindo versões consistentes de bibliotecas e configurações.

Exemplo Prático de Dockerfile

• Para criar um ambiente Node.js:
  • FROM node:16
  • WORKDIR /app
  • COPY package.json .
  • RUN npm install
  • COPY . .
  • CMD ["node", "server.js"]
• Rodar docker build -t minha-app . e docker run minha-app assegura um ambiente consistente em qualquer sistema.
• Os contêineres compartilham o kernel do sistema operacional, reduzindo o consumo de memória e CPU.

Exemplo Prático de Eficiência no Uso de Recursos

• Para verificar o consumo de recursos de um contêiner:
  • docker stats (exibe CPU, memória e uso de rede dos contêineres ativos)
• O Docker possibilita escalar aplicações rapidamente, distribuindo contêineres em diferentes servidores ou com ferramentas como Docker Swarm e Kubernetes.

Exemplo Prático de Escalabilidade

• Para criar múltiplas instâncias de um contêiner:
  • docker run -d --name app1 minha-app
  • docker run -d --name app2 minha-app
  • docker run -d --name app3 minha-app
• As dependências da aplicação estão contidas no contêiner, eliminando problemas de compatibilidade e reduzindo a necessidade de configuração manual.

Exemplo Prático de Gestão Facilitada de Dependências

• Para rodar um banco de dados MySQL sem instalação no sistema:
  • docker run --name meu-mysql -e MYSQL_ROOT_PASSWORD=12345 -d mysql:5.7
• O Docker oferece agilidade, eficiência e confiabilidade, tornando-se essencial para DevOps e arquiteturas modernas, e otimizando o uso de recursos computacionais.

Comandos Essenciais do Docker

• O Docker oferece comandos para criação, gerenciamento e remoção de contêineres e imagens.

1. Criar e Executar um Contêiner

• Para iniciar um contêiner a partir de uma imagem existente.
• Usar o comando docker run.
• A opção -d permite a execução em segundo plano
• A opção --name define um nome.
• Ex: dock run -d --name meu_container minha_imagem

2. Listar Contêineres em Execução

• Para visualizar contêineres ativos.
• Usar o comando docker ps.
• A saída mostra o ID, imagem utilizada, status e portas.

3. Listar Todos os Contêineres

• Para verificar contêineres ativos, interrompidos ou finalizados.
• Usar a flag -a.
• Ex: docker ps -a

4. Acessar o Terminal de um Contêiner em Execução

• Para interagir diretamente com um contêiner.
• Usar docker exec.
• O parâmetro -it permite interação ao vivo
• O comando /bin/sh ou /bin/bash um shell
• Ex: docker exec -it meu_container /bin/sh

5. Parar e Remover um Contêiner

• Para liberar recursos do sistema
• Usar os comandos docker stop meu_container (para parar)
• Usar os comandos docker rm meu_container (para remover)

6. Remover Imagens Não Utilizadas

• Para manter o ambiente limpo e evitar o desperdício de armazenamento
• Usar o comando docker image prune -a
• Permite a gestão eficiente de contêineres, a capacidade de listar contêineres ativos, acessar seus terminais e realizar limpezas periódicas minimiza o ambiente.

O que é o Kubernetes?

• Kubernetes (K8s) é uma plataforma de orquestração de contêineres de código aberto que automatiza a implantação, escalonamento e gerenciamento de aplicações.
• Criado originalmente pelo Google e doado à Cloud Native Computing Foundation (CNCF), o Kubernetes é um padrão para gerenciar workloads conteinerizados, permitindo operar serviços de forma automatizada, resiliente e escalável.
• O Kubernetes permite administrar múltiplos contêineres distribuídos em clusters de servidores, garantindo alta disponibilidade através de balanceamento de carga, auto-recuperação de falhas e escalabilidade automática, além de facilitar a implantação contínua (continuous deployment) com atualizações sem tempo de inatividade.
• Componentes como Pods, Deployments, Services, ConfigMaps e Secrets possibilitam a construção de arquiteturas modernas baseadas em microsserviços e computação em nuvem.

Benefícios do Kubernetes

• O Kubernetes automatiza a gestão de aplicações distribuídas permitindo a implantação, escalabilidade e manutenção de forma eficiente e resiliente.
• Permite gerenciar cargas de trabalho complexas com intervenção manual mínima, otimizando recursos e garantindo alta disponibilidade.

Automatização da Gerência de Contêineres

• O Kubernetes automatiza a implantação, escalonamento e monitoramento, utilizando Deployments, ReplicaSets e Controllers que monitoram continuamente os Pods.

Exemplo prático

• Para criar um Deployment:
  • Criar um Deployment para gerenciar a execução de Pods
  • Ex: apiVersion: apps/v1, kind: Deployment, metadata: name: minha-app, spec: replicas: 3, selector: matchLabels: app: minha-app, template: metadata: labels: app: minha-app, spec: containers: name: minha-app, image: minha-imagem
• Garante a existência de três réplicas da aplicação substituindo automaticamente qualquer Pod que falhar.
• O Kubernetes permite ajustar automaticamente a quantidade de recursos alocados com base na demanda e utilizando o Horizontal Pod Autoscaler (HPA).

Exemplo Prático

• Para configurar um HPA para escalar automaticamente:
  • Através do uso de CPU
  • Ex: kubectl autoscale deployment minha-app --cpu-percent=50 --min=2 --max=10.
• Isso instrui o Kubernetes a manter entre 2 e 10 réplicas com base na carga de trabalho.
• Kubernetes aloca recursos de forma inteligente dentro do cluster, impedindo que um único aplicativo consuma toda a CPU ou memória disponível, além de permitir definir Requests e Limits para cada Pod.

Exemplo Prático

• Para definir limites de recursos para um contêiner:
• apiVersion: v1, kind: Pod, metadata: name: pod-com-limites, spec: containers: name: meu-app, image: minha-imagem, resources: requests: memory: "128Mi”, cpu: "250m”, limits: memory: "512Mi”, cpu: “500m”
• O Kubernetes mantém as aplicações rodando de forma estável mesmo em caso de falhas, utilizando ReplicaSets, Probes e Node Failover.
• Se um Pod falhar, um novo é criado automaticamente, e se um nó ficar indisponível, os Pods são redistribuídos.

Exemplo Prático

• Utilizando livenessProbe para verificar a saúde de um contêiner
• Através do uso de apiVersion: v1, kind: Pod, metadata: name: meu-app, spec: containers: name: minha-app, image: minha-imagem, livenessProbe: httpGet: path: /health, port: 8080, initialDelaySeconds: 3, periodSeconds: 5
• O Kubernetes traz inúmeros benefícios tornando a implantação e gerenciamento eficientes e resilientes, e possibilita empresas manter alta disponibilidade, otimizar custos e ter maior controle sobre seus serviços distribuídos.

Componentes do Kubernetes

• O Kubernetes organiza e gerencia a execução de aplicações distribuídas usando diversos componentes estruturais:

1. Pods: A Unidade Básica de Execução

• Os Pods são a menor unidade de implantação e representam um ou mais contêineres que compartilham o mesmo espaço de execução.

Exemplo Prático

• Criando um Pod manualmente via YAML
  • Ex: apiVersion: v1, kind: Pod, metadata: name: meu-pod, spec: containers: name: meu-container, image: nginx

2. Deployments: Controle de Atualizações e Escalabilidade

• Os Deployments gerenciam a criação, atualização e escalabilidade dos Pods, garantindo que um determinado número de réplicas esteja sempre ativo.

Exemplo Prático

• Para criar um Deployment para manter 3 réplicas de um Pod
  • Ex: apiVersion: apps/v1, kind: Deployment, metadata: name: minha-app, spec: replicas: 3, selector: matchLabels: app: minha-app, template: metadata: labels: app: minha-app, spec: containers: name: minha-app, image: minha-imagem

3. Services: Comunicação e Balanceamento de Carga

• Fornecem um endereço IP fixo e um nome DNS estável para acessar um conjunto de Pods, permitindo o balanceamento de carga

Exemplo Prático

Para expor os Pods de um Deployment através de: - apiVersion: v1, kind: Service, metadata: name: minha-app-service, spec selector: app: minha-app, ports: protocol: TCP, port: 80, targetPort: 8080, type: ClusterIP 4. ConfigMaps e Secrets: Gerenciamento Seguro de Configurações

• ConfigMaps: Armazena variáveis de ambiente e configurações sensíveis.
• Secrets: Armazenam credenciais de forma criptografada.

Exemplo Prático

• Para criar um ConfigMap:
  • Criando um ConfigMap com configurações para um Pod
  • Ex: apiVersion: v1, kind: ConfigMap, metadata: name: minha-config, data: DB_HOST: “meu-banco”,APP_MODE: “production”
• Ex: Criando um Secret para armazenar credenciais
  • apiVersion: v1, kind: Secret
  • metadata: name: meu-segredo, type: Opaque, data: senha: c2VuaGEyMw== # (valor codificado em Base64)

5. Ingress: Controle de Acesso Externo, permite definir regras de roteamento, redirecionamentos e balanceamento de carga, por exemplo:

Exemplo Prático

• Criando um recurso Ingress para expor o serviço na Internet:
  • apiVersion: networking.k8s.io/v1, kind: Ingress, metadata: name: meu-ingress, spec: rules: host: minha-aplicacao.com, http: paths: path: /, pathType: Prefix, backend: service: name: minha-app-service, port: number: 80
• Os componentes do Kubernetes trabalham juntos para garantir um ambiente escalável, resiliente e seguro para aplicações distribuídas, e garante acesso externo seguro e controlado.
• Os Pods fornecem a unidade de execução, os Deployments a replicação/atualização, e os Services garantem a comunicação.

Comandos Essenciais do Kubernetes

• Kubernetes é uma plataforma de orquestração com comandos essenciais para administrar clusters:

1. Criar um Deployment:

• Para gerenciar a criação e atualização de Pods.
• Ex: kubectl create deployment minha_app --image=minha_imagem

2. Listar Pods em Execução:

• Permite verificar os Pods ativos no cluster
• Ex: kubectl get pods

3. Verificar Logs de um Pod:

• Ajuda a identificar erros e analisar o comportamento da aplicação em tempo real.
• Ex:kubectl logs nome_do_pod

4. Excluir um Pod:

• Se um Pod precisar ser removido manualmente.
• Ex: kubectl delete pod nome_do_pod, vale lembrar que se o Pod for gerenciado por um Deployment, ele será recriado automaticamente para manter a quantidade desejada de réplicas

5. Criar um Service para Expor um Deployment:

• Permite a exposição de um Deployment na rede
• Ex: kubectl expose deployment minha_app --type=LoadBalancer --port=80.
• O Kubernetes simplifica a gestão de aplicações conteinerizadas, permitindo criar, monitorar e gerenciar recursos de maneira eficiente, e garante estabilidade, escalabilidade e resiliência das aplicações dentro de um ambiente Kubernetes.

Docker vs Kubernetes

• Docker fornece uma solução simples e eficiente para criar, executar e distribuir contêineres.
• Kubernetes garante que múltiplos contêineres sejam gerenciados de forma escalável e automatizada, possuindo diferentes finalidades e aplicações.

Comparação entre Docker e Kubernetes

• Finalidade: Docker cria/gerencia um contêiner individual, enquanto Kubernetes orquestra contêineres em larga escala
• Portabilidade: Ambos permitem que contêineres rodem em qualquer sistema compatível e gerenciam múltiplos contêineres em ambientes diferentes
• Escalabilidade: O Docker exige comandos explícitos, enquanto o Kubernetes ajusta a quantidade conforme a demanda
• Alocação de Recursos: O Docker permite definir limites básicos, enquanto o Kubernetes distribui cargas de forma otimizada em clusters.
• Automação: O Docker requer intervenção manual, enquanto o Kubernetes automatiza balanceamento/recuperação/escalabilidade
• Uso Recomendado: Docker para pequenos projetos/desenvolvimento, e Kubernetes para aplicações de produção em larga escala.
• O Docker é ideal para desenvolvedores que precisam rodar e testar aplicações localmente. Já o Kubernetes é recomendado para empresas/equipes que operam aplicações complexas em produção.

Docker Compose e Docker Swarm

• Docker Compose permite definir e gerenciar múltiplos contêineres utilizando um arquivo YAML, permitindo as aplicações a dependerem de mais de um serviço, por exemplo:

Exemplo Prático

• Criando um ambiente com Nginx (web server) e PostgreSQL (banco de dados): version: '3' services: web: image: nginx ports: - "80:80" db: image: postgres environment: POSTGRES_PASSWORD: senha123
• Para iniciar os serviços definidos no arquivo, basta executar: docker-compose up -d.
• O Docker Swarm é uma solução nativa do Docker para orquestração de contêineres com funcionalidades semelhantes ao Kubernetes com o seguinte exemplo:

Exemplo Prático

• Inicialização de um cluster Swarm e criação de um serviço Nginx distribuído: "docker swarm init docker service create --name web -p 80:80 nginx"
• Swarm gerencia a distribuição dos contêineres.
• Docker simplifica a execução de contêineres individuais, enquanto o Kubernetes fornece um sistema avançado para gerenciá-los em larga escala, como visto nos exemplos "Shrek e Fiona". Docker Compose facilita o gerenciamento de múltiplos contêineres em um único ambiente, enquanto Docker Swarm