Docker
  • Introdução a Containeres e Docker
    • Introdução
    • O que é um container e suas vantanges
    • VM versus Container
    • Como funcionam os containers
    • Linux
    • Container sem Docker
      • cgroup
      • cpu.max
    • LxC
    • LxD
    • Containers versus Imagens
    • Arquitetura do Docker
    • Arquitetura do Docker mais a fundo
    • Projetos Open Source
  • Instalação do Docker
    • Linux
    • Windows
      • Docker Desktop
      • Rancher Desktop
      • WSL
    • Mac
    • Visual Studio Code
  • Primeiros Passos com Docker
    • Criação e listagem básica de um container
    • Interagindo com o container
    • Executando containers continuamente
      • nginx
      • docker container run
      • docker container run nginx
      • docker container run -d nginx
      • docker container exec
    • Como usar publish de porta
      • docker container stop
      • docker container start
      • docker container rm
      • docker container rm -f $(docker container ls -qa)
    • Containers e variáveis de ambiente
      • docker container run -e
  • Desafio
    • Desafio 01 - Banco de Dados Postgresql
    • Desafio 02 - Banco de Dados MySQL
    • Desafio 03 - Banco de Dados MongoDB
  • Executando a sua primeira aplicação em containers
    • Introdução
    • Preparando o container para a aplicação
    • Executando a aplicação
      • docker container cp
  • Primeiros Passos com Docker Images
    • Introdução
    • OverlayFS na Prática
    • Copy-on-Write
    • Formas de criar uma imagem Docker
    • Como funciona o Docker Commit
    • Docker Commit na Prática
      • docker commit
    • Entendendo melhor a sua imagem
      • docker image history
      • docker image inspect
    • Entrando mais a fundo na imagem
    • Como usar a imagem Docker no modo raiz
  • Avançando em imagens Docker com Dockerfile
    • O que é Dockerfile
    • Primeira Imagem com Dockerfile
      • docker image build
    • Como funciona a construção com Dockerfile
    • Possibilidades com Dockerfile
    • FROM
    • RUN
    • WORKDIR
    • COPY
    • ADD
    • LABEL
    • ENV
    • VOLUME
    • ARG
    • EXPOSE
    • USER
    • ENTRYPOINT
    • CMD
    • ENTRYPOINT versus CMD
    • Principais comandos com imagem
    • Imagem da aplicação com Dockerfile
    • Comparando Docker Commit com Dockerfile
  • Docker Registry
    • Introdução
    • Docker Hub
    • Sua imagem com o nome certo
    • Renomear imagens com Docker Tag
      • docker image tag
    • Enviando a sua primeira imagem para o Docker Hub
      • docker image push
      • docker image pull
  • Algumas boas práticas para construção de imagem
    • Um processo por container
    • Usar imagens confiáveis
    • Otimizar sempre a sua imagem
    • Uso inteligente das camadas
    • Dockerignore
  • Multistage Build
    • Introdução
    • Multistage build na prática
    • Target para fazer o build
      • docker image build --target
    • Imagem externa no Multistage build
    • Usar um estágio de build como base
  • Docker Volume
    • Introdução
      • docker volume
    • Bind Mount
    • Particularidades do Bind Mount
    • Bind Mount no Windows
    • Exemplo com Bind Mount
    • Docker Volume
      • docker volume create
      • docker volume inspect
      • docker volume ls
      • docker volume prune
      • docker volume rm
    • Onde ficam os arquivos do Docker volume?
    • Usando o volume no Dockerfile
    • Como fazer backup de um Docker Volume
    • Exemplo com Docker Volume
    • Storage tmpfs
    • Como criar algo funcional com o que aprendemos
  • Network
    • Introdução
    • Componentes do Docker Network
    • Rede Bridge na prática
      • docker network
      • docker network create
      • docker network inspect
      • docker network ls
      • docker network prune
      • docker network rm
    • Criando a sua rede bridge
      • docker network connect
      • docker network disconnect
    • Como funciona a rede bridge por dentro
    • Rede Host na prática
    • Rede none da prática
    • Como adicionar domínios no seu container
  • Aplicação 100% no Docker
    • Introdução
    • Criação da Imagem e Envio para o Docker Hub
    • Criação do Docker Network
    • Container do PostgreSQL
    • Container da Aplicação Web
    • Atualização da aplicação
  • Docker Compose
    • Introdução
      • docker compose
    • A evolução do docker compose
    • Criação básica de um Docker Compose
      • docker compose attach
      • docker compose build
      • docker compose config
      • docker compose cp
      • docker compose create
      • docker compose down
      • docker compose events
      • docker compose exec
      • docker compose images
      • docker compose kill
      • docker compose logs
      • docker compose ls
      • docker compose pause
      • docker compose port
      • docker compose ps
      • docker compose pull
      • docker compose push
      • docker compose restart
      • docker compose rm
      • docker compose run
      • docker compose scale
      • docker compose start
      • docker compose stats
      • docker compose stop
      • docker compose top
      • docker compose unpause
      • docker compose up
      • docker compose version
      • docker compose wait
      • docker compose watch
    • Variáveis de Ambiente
    • Volume Bind Mount
    • Docker Volume
    • Docker Network - Bridge
    • Docker Network - Host Driver e Add Host
    • Ordenando a execução dos containers
    • Compose com build de imagem
    • Como Parametrizar o Compose com Variáveis de Ambiente
    • Múltiplos Composes
    • Extends
    • Merge
    • Include
    • Profiles
    • Comandos importantes do Docker Compose
  • Troubleshooting
    • Introdução
    • Docker Info
    • Docker Events
    • Docker Logs
    • Docker Inspect
    • Docker Top
    • Docker Stats
    • Docker Exec
  • Resiliência e Gerenciamento de Recursos
    • Introdução
    • Docker Restart
      • Introdução
      • on-failure
      • unless-stopped
      • always
      • Docker Compose
    • Healthcheck
      • Introdução
      • Linha de Comando
      • Docker Compose
      • Direto na Imagem
    • Gerenciamento de Recurso
      • CPU
        • Como Gerenciar CPU
        • Prática
      • Memória
        • Como Gerenciar Memória
        • Prática
      • Docker Compose
  • Fazendo um ambiente mais seguro
    • Introdução
    • Docker Scout
      • Introdução
      • Verificação Simples de Imagem
      • Como adicionar um repositório
      • Primeira melhoria na imagem
  • BUSCA RÁPIDA
    • Referências
    • Comandos
      • docker commit
      • docker compose
      • docker container
      • docker image
      • docker network
      • docker volume
    • Dockerfile
Powered by GitBook
On this page
  • Conceito Básico
  • Como Funciona
  • Namespaces
  • Cgroups
  • Chroot
  • Vantagens
  • Leveza
  • Eficiência
  • Isolamento
  • Uso Comum
  • Hospedagem de Aplicações
  • Desenvolvimento e Testes
  • Segurança
  • Comparação com Outras Tecnologias
  • Docker
  • Máquinas Virtuais
  • Exemplo de Uso
  • Laboratório
  1. Introdução a Containeres e Docker

LxC

LinuX Containers

LxC (LinuX Containers) é uma tecnologia de virtualização a nível de sistema operacional no Linux, que permite executar múltiplos sistemas Linux isolados em um único host. Aqui está um resumo de suas principais características e funcionalidades:

Conceito Básico

LxC é uma implementação de contêineres no Linux que utiliza recursos do kernel, como cgroups (control groups) e namespaces, para criar ambientes de usuário isolados. Esses ambientes funcionam como se fossem sistemas operacionais independentes, mas compartilham o mesmo kernel do host.

Como Funciona

Namespaces

O LxC usa namespaces para isolar diferentes aspectos do sistema, como processos, rede, montagem de sistemas de arquivos, IDs de usuários, etc. Isso significa que cada contêiner pode ter sua própria visão do sistema sem interferir nos outros.

Cgroups

O LxC usa cgroups para gerenciar e limitar recursos, como CPU, memória, disco e rede, garantindo que cada contêiner tenha acesso a uma quantidade controlada desses recursos.

Chroot

LxC usa uma estrutura semelhante ao chroot para fornecer um sistema de arquivos isolado para cada contêiner, o que significa que cada contêiner tem seu próprio diretório raiz (/).

Vantagens

Leveza

Diferente de máquinas virtuais, que precisam de um hypervisor e um kernel completo para cada instância, os contêineres LxC compartilham o kernel do host, tornando-os muito mais leves em termos de consumo de recursos.

Eficiência

Como os contêineres compartilham o mesmo kernel, a inicialização e o desempenho são muito mais rápidos do que em ambientes de virtualização tradicionais.

Isolamento

Oferece isolamento de processos, rede e sistema de arquivos, o que é útil para ambientes multi-tenant, testes, e ambientes de desenvolvimento.

Uso Comum

Hospedagem de Aplicações

LxC é frequentemente usado para hospedar múltiplas aplicações isoladas em servidores, permitindo um controle mais fino sobre o ambiente de cada aplicação.

Desenvolvimento e Testes

Desenvolvedores usam LxC para criar ambientes de desenvolvimento e teste que replicam ambientes de produção de forma eficiente.

Segurança

LxC pode ser usado para isolar aplicações sensíveis, aumentando a segurança ao garantir que falhas ou invasões em um contêiner não afetem outros contêineres ou o sistema host.

Comparação com Outras Tecnologias

Docker

Docker também utiliza contêineres, mas com um foco maior na portabilidade e na automação de implantação de aplicações. Enquanto o LxC oferece mais flexibilidade e controle em nível de sistema, Docker simplifica a criação e distribuição de aplicações em contêineres.

Máquinas Virtuais

Diferente de máquinas virtuais que emulam hardware completo, LxC oferece uma abordagem mais leve, já que os contêineres compartilham o kernel do sistema host.

Exemplo de Uso

Para criar e iniciar um contêiner usando LxC:

sudo lxc-create  -n mycontainer -t ubuntu  # Cria um contêiner Ubuntu chamado "mycontainer"
sudo lxc-start   -n mycontainer            # Inicia o contêiner
sudo lxc-attach  -n mycontainer            # Acessa o shell do contêiner
sudo lxc-stop    -n mycontainer            # Para o contêiner
sudo lxc-stop -k -n mycontainer            # Força a parada do contêiner

LxC é uma ferramenta poderosa para criar ambientes isolados de forma eficiente e segura, amplamente usada em desenvolvimento, testes, e ambientes de produção.

Laboratório

Docker:

  • Objetivo: executar processos de forma isolada

LxC:

  • Baseado em template

  • Cria SO de forma isolada, como se fossem VM dentro de containeres

  • Bastante utilizado

Instalação do LxC:

$ sudo apt update
$ sudo apt install lxc lxc-templates

Criação do container:

$ sudo lxc-create -t ubuntu -n meucontainer

Listar o container:

$ sudo lxc-ls --fancy

Iniciar o container:

$ sudo lxc-start -n meucontainer
$ sudo lxc-ls --fancy
$ ps -ef --forest

Para acessar o container:

$ sudo lxc-attach -n meucontainer

Possui isolamento de container e de host.

Processos do container:

$ ps -aux

O LxC trata o container como se fosse uma máquina

O container não possui o SO completo:

$ ls /boot
$

Para o container:

$ sudo lxc-stop -n meucontainer
$ sudo lxc-ls --fancy
Previouscpu.maxNextLxD

Last updated 9 months ago

Linux Containers
Logo