Docker

Comandos Docker

Este é um roadmap completo e profissional de comandos Docker e sua documentação. Ele foi criado para ajudar novos usuários a aprenderem Docker, desde os conceitos básicos até os mais avançados.

Índice

• 📱 Nível Iniciante
• 🎉 Instalando Docker
  • Windows
  • Linux
  • MacOS

---

Nível Iniciante

Instalando Docker

Note: Antes de começar a usar Docker, você precisará instalá-lo em seu sistema. Os seguintes guias de instalação estão disponíveis para diferentes sistemas operacionais:

• Instalação do Docker no Linux
• Instalação do Docker no Windows
• Instalação do Docker no Mac

---

Para instalar o Docker em um sistema Linux, execute o seguinte comando:

sudo apt-get update
sudo apt-get install docker-ce

Para instalar o Docker em um sistema Windows ou macOS, faça o download do instalador apropriado no site oficial do Docker e siga as instruções de instalação.

Verificando a Instalação

Para verificar se o Docker está instalado corretamente, execute o seguinte comando:

docker --version

Isso deve exibir a versão do Docker instalada no sistema.

Executando um Contêiner

Após instalar o Docker, para executar um contêiner a partir de uma imagem, use o comando docker run seguido do nome da imagem:

docker run <nome_da_imagem>

Este comando inicia um contêiner a partir da imagem especificada. Se a imagem não estiver presente em sua máquina, o Docker a baixará automaticamente da Docker Hub.

Por exemplo, para executar um contêiner a partir da imagem do Ubuntu, execute o seguinte comando:

docker run ubuntu

Listando Contêineres em Execução

Para listar todos os contêineres em execução em sua máquina, use o seguinte comando:

docker ps

Este comando lista apenas os contêineres em execução. Se você quiser listar todos os contêineres, incluindo os que não estão em execução, adicione a opção -a:

docker ps -a

Parando um Contêiner em Execução

Para parar um contêiner em execução, use o seguinte comando:

docker stop <id_do_contêiner>

Você pode encontrar o ID do contêiner usando o comando docker ps.

O ID do contêiner pode ser obtido a partir da saída do comando docker ps.

Removendo um Contêiner

Para remover um contêiner, use o seguinte comando:

docker rm <id_do_contêiner>

Novamente, você pode encontrar o ID do contêiner usando o comando docker ps.

Exibindo Logs de um Contêiner

Para exibir os logs de um contêiner em execução, execute o seguinte comando:

docker logs <ID_do_contêiner>

Listando Imagens Disponíveis

Para listar todas as imagens disponíveis em sua máquina, use o seguinte comando:

docker images

Obtendo uma Shell em um Contêiner

Para obter uma shell em um contêiner em execução, execute o seguinte comando:

docker exec -it <ID_do_contêiner> /bin/bash

Volte ao inicio da Documentação 🔝

Nível Intermediário

Criando uma Imagem

Para criar sua própria imagem, você precisa escrever um Dockerfile. Um Dockerfile é um arquivo de texto que contém todas as instruções necessárias para construir uma imagem. Aqui está um exemplo simples de um Dockerfile:

FROM alpine:latest
RUN apk add --update nginx
CMD ["nginx", "-g", "daemon off;"]

Para criar a imagem a partir deste Dockerfile, execute o seguinte comando:

docker build -t <seu_nome_de_usuário>/<nome_da_imagem> .

Este comando cria uma nova imagem com o nome especificado e o ponto final indica que o Dockerfile está localizado no diretório atual.

Por exemplo, para construir uma imagem a partir de um Dockerfile no diretório atual com o nome "myimage", execute o seguinte comando:

docker build -t myimage .

Publicando uma Imagem no Docker Hub

Para publicar uma imagem no Docker Hub, primeiro crie uma conta no site oficial do Docker Hub. Em seguida, execute os seguintes comandos:

docker login
docker tag <nome_da_imagem> <nome_do_usuário_no_Docker_Hub>/<nome_da_imagem>
docker push <nome_do_usuário_no_Docker_Hub>/<nome_da_imagem>

Executando um Contêiner em Modo Interativo

Para executar um contêiner em modo interativo, use o seguinte comando:

docker run -it <nome_da_imagem> /bin/bash

Este comando inicia um contêiner a partir da imagem especificada e abre um shell interativo no contêiner.

Expondo uma Porta

Para expor uma porta em um contêiner, use a opção -p seguida da porta que deseja expor:

docker run -p <porta_do_host>:<porta_do_contêiner> <nome_da_imagem>

Este comando expõe a porta do contêiner especificada para a porta do host especificada.

Montando um Volume

Para montar um volume em um contêiner, use a opção -v seguida do caminho do diretório no host e no contêiner:

docker run -v <caminho_do_host>:<caminho_do_contêiner> <nome_da_imagem>

Este comando monta o diretório do host especificado no contêiner.

Usando Volumes

Os volumes do Docker permitem que os dados sejam compartilhados entre contêineres e persistam mesmo que o contêiner seja excluído. Para montar um volume em um contêiner, use a opção -v seguida do caminho do host e do caminho do contêiner:

docker run -v <caminho_do_host>:<caminho_do_contêiner> <nome_da_imagem>

Por exemplo, para montar o diretório /data no host no diretório /app/data no contêiner, execute o seguinte comando:

docker run -v /data:/app/data <nome_da_imagem>

Trabalhando com Redes

O Docker possui suporte para redes, o que permite que contêineres se comuniquem entre si e com o mundo exterior. Aqui está um exemplo simples de como criar uma rede e conectar contêineres a ela:

Cria uma nova rede

docker network create minha-rede

Gerenciando Redes

O Docker permite criar redes personalizadas para contêineres se comunicarem. Para criar uma rede, execute o seguinte comando:

docker network create <nome_da_rede>

Para conectar um contêiner a uma rede, use a opção --network seguida do nome da rede:

docker run --network=<nome_da_rede> <nome_da_imagem>

Cria dois contêineres e os conecta à nova rede

docker run --name cont1 --network minha-rede -d nginx
docker run --name cont2 --network minha-rede -d nginx

Este comando cria uma nova rede chamada "minha-rede" e inicia dois contêineres nginx, que são conectados à nova rede.

Usando Comandos do Docker Compose

O Docker Compose é uma ferramenta para definir e executar aplicativos Docker multi-contêiner em diferentes ambientes. Ele usa um arquivo YAML para configurar os serviços do aplicativo, as dependências e as redes. Aqui está um exemplo simples de um arquivo docker-compose.yml:

version: '3'

services:
  web:
    image: nginx
    ports:
      - "80:80"
  db:
    image: mysql
    environment:
      MYSQL_ROOT_PASSWORD: example

Para executar este aplicativo, basta executar o comando docker-compose up no diretório onde o arquivo docker-compose.yml está localizado.

Expondo Portas

Para expor uma porta de um contêiner para o host, use a opção -p seguida da porta do host e da porta do contêiner:

docker run -p <porta_do_host>:<porta_do_contêiner> <nome_da_imagem>

Por exemplo, para expor a porta 80 do contêiner para a porta 8080 do host, execute o seguinte comando:

docker run -p 8080:80 <nome_da_imagem>

Exibindo Informações de Uso

Para exibir informações sobre o uso de recursos do Docker, execute o seguinte comando:

docker stats

Volte ao inicio da Documentação 🔝

Nível Avançado

Gerenciando Imagens

Para listar as imagens no sistema, execute o seguinte comando:

docker images

Para remover uma imagem, execute o seguinte comando:

docker rmi <nome_da_imagem>

Gerenciando Volumes

Para listar os volumes no sistema, execute o seguinte comando:

docker volume ls

Para remover um volume, execute o seguinte comando:

docker volume rm <nome_do_volume>

Usando a API do Docker

A API do Docker permite que você gerencie contêineres, imagens e outros recursos do Docker programaticamente. Para usar a API do Docker, consulte a documentação oficial da API.

Usando Docker Swarm

O Docker Swarm é uma ferramenta para criar e orquestrar clusters Docker. Ele permite que você gerencie um conjunto de contêineres como se fossem uma única entidade. Aqui está um exemplo simples de como criar um cluster Swarm:

Inicia um novo Swarm

docker swarm init

Adiciona um nó ao Swarm

docker swarm join --token <token> <endereço_do_mestre>

Cria um serviço no Swarm

docker service create --replicas 3 --name web nginx

Este comando inicia um novo Swarm, adiciona um nó ao Swarm e cria um serviço que consiste em três réplicas do contêiner nginx.

Trabalhando com Imagens do Docker Hub

O Docker Hub é um registro público de imagens Docker. Você pode pesquisar e baixar imagens do Docker Hub usando o seguinte comando:

docker pull <nome_da_imagem>

Configurando o Docker Compose

O Docker Compose é uma ferramenta para definir e executar aplicativos Docker com vários contêineres. Ele usa um arquivo YAML para definir os serviços necessários para o aplicativo e pode iniciar vários contêineres de uma vez.

Para configurar um aplicativo usando o Docker Compose, crie um arquivo docker-compose.yml com a definição dos contêineres e execute o seguinte comando:

docker-compose up

Isso criará e iniciará todos os contêineres definidos no arquivo docker-compose.yml.

Usando o Docker Compose

Para usar o Docker Compose, você precisa escrever um arquivo docker-compose.yml. Aqui está um exemplo simples:

version: '3'
services:
  web:
    build: .
    ports:
      - "8080:80"
    volumes:
      - .:/code
  db:
    image: postgres
    environment:
      POSTGRES_PASSWORD: example

Este arquivo define dois serviços: web e db. O serviço web é construído a partir do diretório atual (.) e expõe a porta 80 do contêiner para a porta 8080 do host. Ele também monta o diretório atual para o diretório /code no contêiner. O serviço db usa a imagem do Postgres e define a variável de ambiente POSTGRES_PASSWORD.

Para iniciar os serviços definidos no arquivo docker-compose.yml, execute o seguinte comando:

docker-compose up

Usando a API do Docker O Docker também tem uma API que permite controlar os contêineres, imagens e outros recursos do Docker programaticamente. A API é acessível por meio de uma interface HTTP e pode ser usada por qualquer linguagem de programação que possa fazer solicitações HTTP.

A documentação completa da API do Docker está disponível em Docs

Para usar a API do Docker em uma aplicação, você pode usar uma biblioteca cliente para sua linguagem de programação. Algumas bibliotecas cliente populares são:

• Docker SDK for Python
• Docker SDK for Java
• Docker SDK for Go

Volte ao inicio da Documentação 🔝

Utilizando Docker e Sequelize

Docker

• Para saber mais do Docker visite aqui.

Sequelize

• É um ORM (é uma forma de abstração do banco de dados)

Como manipular os dados?

• Será sem SQL mas em javascript

SQL

INSERT INTO users (name, email)
  VALUES (
    "Ilda Neta",
    "[email protected]"
  )

User.create({
  name: 'Ilda Neta',
  email: '[email protected]'
})

Configurando o Sequelize

yarn add sequelize yarn add sequelize-cli -D

• Criar na raíz do projeto o arquivo .sequelizerc

  • Inserir as configurações:

   const {resolve} = require('path');
  
   module.exports = {
    config: resolve(__dirname, 'src', 'config', 'database.js'),
    'models-path': resolve(__dirname, 'src', 'app', 'models'),
    'migrations-path': resolve(__dirname, 'src', 'database', 'migrations'),
    'seeders-path': resolve(__dirname, 'src', 'database', 'seeds'),
  }

• Inserir as configurações dentro da pasta config -> database.js:

module.exports = {
  dialect: 'postgres',
  host: 'localhost',
  username: 'postgres',
  password: 'docker',
  database: 'gobarber',
  define: {
    timestamp: true,
    underscored: true,
    underscoredAll: true
  }
};

• Instalar yarn add pg pg-hstore

Criando a 1ª Migration

• Clicar na pasta de database -> migrations -> rodar o comando yarn sequelize migration:create --name=create-users para que seja criado o arquivo de migrations que criará a tabela de usuários

• No arquivo criado, iremos inserir os campos que teremos e informar:

  • o tipo do campo
  • se aceita valores nulos ou não
  • informar o campo que será a chave primária
  • o seu valor default

• O arquivo final ficou:

module.exports = {
  up: (queryInterface, Sequelize) => {
    return queryInterface.createTable('users', {
      id: {
        type: Sequelize.INTEGER,
        allowNull: false,
        autoIncrement: true,
        primaryKey: true,
      },
      name: {
        type: Sequelize.STRING,
        allowNull: false,
      },
      email: {
        type: Sequelize.STRING,
        allowNull: false,
        unique: true,
      },
      password_hash: {
        type: Sequelize.STRING,
        allowNull: false,
      },
      provider: {
        type: Sequelize.BOOLEAN,
        defaultValue: false,
        allowNull: false,
      },
      created_at: {
        type: Sequelize.DATE,
        allowNull: false,
      },
      updated_at: {
        type: Sequelize.DATE,
        allowNull: false,
      },
    });
  },

  down: queryInterface => {
    return queryInterface.dropTable('users');
  },
};

• Para criar as tabelas e rodar o que colocamos no migrations é necessário rodar o comando yarn sequelize db:migrate

- Sempre lembrar de iniciar o banco de dados antes de rodar comandos do sequelize: docker start database

• Para desfazer a última migration enviada, caso você tenha esquecido é necessário rodar yarn sequelize db:migrate:undo e depois rodar novamente o yarn sequelize db:migrate para a migrate subir novamente.
• Para desfazer todas as migrations enviadas é necessário rodar yarn sequelize db:migrate:undo:all

Criando o Model de usuários

• Servirá para podermos criar usuários, deletar, alterar
• No 1º objeto, colocaremos todas as colunas de valores que o usuário pode receber no momento de criação / alteração
• No 2º objeto passaremos o parâmetro sequelize

import Sequelize, { Model } from 'sequelize';

class User extends Model {
  static init(sequelize) {
    super.init(
      {
        name: Sequelize.STRING,
        email: Sequelize.STRING,
        password_hash: Sequelize.STRING,
        provider: Sequelize.BOOLEAN,
      },
      {
        sequelize,
      }
    );
  }
}

export default User;

Criando Loader de Models

• O Loader servirá para criar a conexão com o banco de dados postgres que definimos no database, além desse arquivo carregar todos os Models da aplicação

• Criar um arquivo index.js dentro da pasta database

  • O método init() será o responsável por realizar a conexão com a base de dados e carregar os models

import User from '../app/models/User';

import databaseConfig from '../config/database';

const models = [User];

class Database {
  constructor() {
    this.init();
  }

  init() {
    this.connection = new Sequelize(databaseConfig);

    models.map(model => model.init(this.connection));
  }
}

export default new Database();

• Depois é necessário importarmos nossa pasta de database dentro do arquivo app.js import './database';

Criando o cadastro de usuários

• Criaremos agora a criação de usuários dentro da API
• Criar um arquivo chamado UserController.js dentro da pasta de controllers
• Criamos também uma validação do e-mail do usuário, pois o mesmo deve ser único

import User from '../models/User';

class UserController {
  async store(req, res) {
    const userExists = await User.findOne({ where: { email: req.body.email } });
    if (userExists) {
      return res.status(400).json({ error: 'User already exists.' });
    }

    const { id, name, email, provider } = await User.create(req.body);

    return res.json({
      id,
      name,
      email,
      provider,
    });
  }
}

export default new UserController();

Gerando o hash da senha do usuário

• É necessário adicionar o pacote yarn add bcryptjs

• Iremos voltar no arquivo User.js que é nosso Model de usuário, e iremos importar o bcrypt e criar um novo campo que se chamará password

  • Esses campos do Model não precisam refletir 100% o que criamos em database
  • O campo senha será do tipo Virtual, pois é um campo que não existirá na base de dados, apenas no código (virtual)
    • Criaremos um hook que antes de salvar o usuário no bd, gerará um hash da senha que foi digitada (uma senha criptografada)
  • Foi criado também um método chamado checkPassword para comparar a senha de hash do usuário com a senha que ele digitou

import Sequelize, { Model } from 'sequelize';
import bcrypt from 'bcryptjs';

class User extends Model {
  static init(sequelize) {
    super.init(
      {
        name: Sequelize.STRING,
        email: Sequelize.STRING,
        password: Sequelize.VIRTUAL,
        password_hash: Sequelize.STRING,
        provider: Sequelize.BOOLEAN,
      },
      {
        sequelize,
      }
    );
    this.addHook('beforeSave', async user => {
      if (user.password) {
        user.password_hash = await bcrypt.hash(user.password, 8);
      }
    });

    return this;
  }
   // return true or false for the comparation of passwords
  checkPassword(password) {
    return bcrypt.compare(password, this.password_hash);
  }
}

export default User;

JWT

• O JWT(Jason Web Token) é uma metodologia de autenticação em API's REST

Criando a autenticação do usuário

• Criar um arquivo chamado SessionController.js dentro da pasta de controllers

• Será necessário instalar o jsonwebtoken que gerará nossos tokens em formato JSON yarn add jsonwebtoken

• Um dos dados de nossa resposta será o token, que receberá o método sign que necessita no mínimo 3 parâmetros 1º - Payload(informações adicionais que queremos incorporar dentro do token) e deve ser no formato de objeto 2º - Precisa ser uma string única e segura, podemos ir no MD5 online e gerar um hash que só nós teremos e inserí-lo nesse parâmetro 3º - São algumas configurações que podemos passar para esse token, deve ser no formato de objeto também, nesse caso passamos que a validade do token irá expirar em '7d' 7 dias

• É necessário criar um arquivo dentro da pasta de config chamado auth.js que conterá as configurações da parte de autenticação da aplicação e depois será importado dentro do nosso arquivo de SessionCrontrollers

import jwt from 'jsonwebtoken';
import authConfig from '../../config/auth';
import User from '../models/User';

class SessionController {
  async store(req, res) {
    const { email, password } = req.body;

    const user = await User.findOne({ where: { email } });

    // checking if the user email exits
    if (!user) {
      return res.status(401).json({ error: 'User not found!' });
    }

    // checking if the user password is correctly
    if (!(await user.checkPassword(password))) {
      return res.status(401).json({ error: 'Password does not match!' });
    }

    const { id, name } = user;

    return res.json({
      user: {
        id,
        name,
        email,
      },
      token: jwt.sign({ id }, authConfig.secret, {
        expiresIn: authConfig.expiresIn,
      }),
    });
  }
}

export default new SessionController();

Volte ao inicio da Documentação 🔝