GitHub Actions

    Nesse artigo rápido eu mostro um exemplo do uso do GitHub Actions para um projeto Java. O arquivo deve ficar em uma pasta workflow dentro da pasta .github do projeto (.github/workflows).

name: CI/CD with Docker and GitHub Actions

on:

  push:

    branches:

      - main

jobs:

  build:

    runs-on: ubuntu-latest

    steps:

    - name: Checkout repository

      uses: actions/checkout@v2

    - name: Build Docker image

      run: docker build -t gbdaniel/projeto:latest .

    - name: Log into Docker Hub

      run: docker login -u gbdaniel -p ${{ secrets.DOCKERHUB_TOKEN }}

    - name: Push image to Docker Hub

      run: docker push gbdaniel/projeto:latest

  deploy:

    runs-on: ubuntu-latest

    needs: build

    steps:

    - name: Install SSH key

      uses: webfactory/ssh-agent@v0.5.3

      with:

        ssh-private-key: ${{ secrets.SSH_PRIVATE_KEY }}

    - name: SSH into EC2 instance and update Docker Compose

      run: |

        ssh -o StrictHostKeyChecking=no ec2-user@IP_DO_SERVIDOR_EC2 "cd /home/ec2-user && docker-compose pull && docker-compose up -d"

Instalando o Docker no Windows usando WSL 2 e Ubuntu

          Nesse artigo vamos configurar o Docker pra rodar no Ubuntu através do WSL 2 de forma nativa (como se a máquina fosse Linux puro). Caso não tenha o WSL 2 configurado veja aqui como fazer: Configuração WSL 2

 

Agora vamos ao Docker! O primeiro passo é atualizar a biblioteca do Ubuntu de gerenciamento de programas:

 Obs: Para versão 22-4 do Ubuntu ver aqui. 

$ sudo apt update && sudo apt upgrade

 

Depois instalar as dependências como Http, certificados, acesso a URLs, etc...

 

$ sudo apt-get install \

    apt-transport-https \

    ca-certificates \

    curl \

    gnupg \

    lsb-release

 

Agora adicionar o repositório Docker na biblioteca do Ubuntu:

 

$ sudo mkdir -p /etc/apt/keyrings

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

 

Agora para configurar o repositório:

 

$ echo \

  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \ $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

 

Vamos mais uma vez atualizar a biblioteca:

 

$ sudo apt-get update

 

Agora sim vamos instalar o Docker. Para a instalar a última versão usamos:

 

$ sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin

 

Para instalar uma versão específica primeiro listamos as versões:

 

$ apt-cache madison docker-ce | awk '{ print $3 }'

 

E então instalamos a que desejamos. Ex:

 

$ VERSION_STRING=5:20.10.13~3-0~ubuntu-jammy

$ sudo apt-get install docker-ce=$VERSION_STRING docker-ce-cli=$VERSION_STRING containerd.io docker-compose-plugin

 

É preciso também dar permissão a pasta criada. A instalação do Docker já espera que haja um grupo chamado "docker". Veja com o comando "groups" se esse grupo "docker" já existe, caso não tenha sido criado, siga as duas linhas abaixo, caso tenha sido criado, apenas adicione seu usuário a ele.

 

$ sudo groupadd Docker

$ sudo usermod -aG docker $USER

 

Pronto, agora é só fazer logoff e login ou fechar o app do Ubuntu e abrir novamente para poder usar o docker.

 

Atenção! Em alguns casos ao sair e entrar no App do Ubuntu (e outras distribuições) ele desliga o serviço do Docker. Caso isso aconteça pode ser resolvido da seguinte maneira:

 

$ sudo systemctl enable docker.service

$ sudo systemctl enable containerd.service

 

Isso adiciona o serviço do Docker ao Systemd que gerencia serviços que inicializam automaticamente. Caso queira remover basta usar o "disable" ao invés do "enable".

 

 

Fonte:

https://docs.docker.com/engine/install/ubuntu/

https://docs.docker.com/engine/install/linux-postinstall/

https://github.com/codeedu/wsl2-docker-quickstart#instala%C3%A7%C3%A3o-do-wsl-2

 

Configurando o WSL 2 no Windows 10 - (Linux no Windows)

           Nesse artigo vou mostrar como configurar o WSL 2 no Windows para podermos usar uma distribuição Linux como se estivéssemos rodando ela direto sobre o hardware sem o Windows.

 

Abra o PowerShell em modo administrador e execute os comandos para habilitar o WSL 2:

 

> dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart

 

> dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart

 

Teste o comando wsl, se não funcionar é preciso reiniciar o computador. Funcionando, baixe e instale o kernel do WSL no endereço:  https://docs.microsoft.com/pt-br/windows/wsl/wsl2-kernel 

 

Agora mude a versão do WSL para a 2:

 

> wsl --set-default-version 2

  

Pronto, agora na Windows Store você escolhe a distribuição que você quer e clica em instalar. Geralmente a mais usada é o Ubuntu, mas fica a seu critério. No processo de instalação ou primeiro acesso vai ser pedido para você fornecer um nome de usuário e senha para o S.O do Linux. Você pode fornecer os mesmos que usa no Windows ou outro.

 

 

Fonte:

https://learn.microsoft.com/pt-br/windows/wsl/

https://github.com/codeedu/wsl2-docker-quickstart#instala%C3%A7%C3%A3o-do-wsl-2

 

Criando chave SSH dentro do Gitlab Runner para automação do Deploy - CI/CD

      Nesse post eu mostro como criar uma chave SSH no Gitlab Runner para usá-la no Servidor de Deploy como host conhecido, permitindo o deploy sem a necessidade de login e senha, permitindo a automação do processo.

      Aqui assumimos que já se tem o Gitlab Runner configurado e rodando  na máquina desejada.

     Entramos no terminal do container:

$ docker exec - it gitlab-runner bash

     Mudamos para o usuário gitlab-runner

$ su gitlab-runner

     Executamos o comando que cria a chave e seguimos os passos seguintes apenas dando enter para que fique com as configurações padrão.

$ ssh-keygen

     

     Agora que a chave foi criada. Vamos copiá-la para configurá-la na máquina de deploy.

$ cd  /home/gitlab-runner/.ssh

$ cat id_rsa.pub

      Copiamos o conteúdo e vamos para o servidor de deploy. Nele vamos procurar o arquivo authorized_keys onde devemos colocar o conteúdo copiado. Esse arquivo fica no diretório raiz do usuário na pasta .ssh/, pode ser que já tenham outras chaves nele ou que seja ncessário criar do zero esse arquivo. 

     Ao colar lá a chave ssh pública, volte no container do Gitlab Runner e faça o primeiro acesso para testar. Lembre-se de estar com o usuário gitlab-runner.

$ docker exec - it gitlab-runner bash

$ su gitlab-runner

$ ssh usuario@ip_da_maquina_deploy

     Como é a primeira vez, aceite a conexão ssh. Pronto, agora o processo de deploy é pra funcionar normalmente.

Erro ao Criar Runner Gitlab no Docker Toolbox - Error response from daemon: invalid mode: \MinGW\msys\1.0\etc\gitlab-runner.

      Nesse post eu mostro como resolver um problema de criar um Runner do Gitlab para quem usa o Docker Toolbox. Sabe o que é o Docker Toolbox? Um projeto (que até foi descontinuado, porém eu uso devido a problemas que tive com o Docker rodando direto na minha máquia e outras coisas que uso) que instala as ferramentas Docker (Docker Engine, Docker Machine, etc)  dentro de uma "caixa" que abstrai as características da sua máquina e roda o Docker independentemente delas. Como tudo no mundo, isso tem vantagens e desvantagens. Como o Docker Toolbox roda dentro dessa "caixa" algumas coisas funcionam um pouco diferentes. Os volumes são uma delas.

     Após baixar a imagem do Runner com o comando:

$ docker pull gitlab/gitlab-runner:latest

     Quando vamos executar o comando que sobe  o Runner criando os volumes:

$   docker run -d --name gitlab-runner --restart always -v /Users/Shared/gitlab-runner/config:/etc/gitlab-runner -v /var/run/docker.sock:/var/run/docker.sock gitlab/gitlab-runner:latest

     Recebemos o seguinte erro:

c:\Program Files\Docker Toolbox\docker.exe: Error response from daemon: invalid mode: \MinGW\msys\1.0\etc\gitlab-runner. 

See 'c:\Program Files\Docker Toolbox\docker.exe run --help'.

     E procurando a solução, encontrei e foi bem simples, basta adicionar uma barra "/" a mais no início dos caminhos do volume, ficando assim:

$ docker run -d --name gitlab-runner --restart always -v //Users/Shared/gitlab-runner/config://etc/gitlab-runner -v //var/run/docker.sock://var/run/docker.sock gitlab/gitlab-runner:latest 

     Pronto. Agora funciona tranquilo.

https://stackoverflow.com/questions/50540721/docker-toolbox-error-response-from-daemon-invalid-mode-root-docker

Principais comandos do Docker Swarm

 Nesse artigo vou trazer o resumo dos principais comandos do Docker Swarm.

·        docker swarm init --advertise-addr <ip_máquina> – Mostra o status do swarm

·        docker info – Mostra o status do swarm

·        docker node ls – Exibe informações sobre os nós

·        docker swarm join-token worker – Mostra o comando necessário para adicionar um

nó como worker ao swarm. O comando que resulta como saída deve ser aplicado na VM 

a ser adicionada.

·        docker service create --replicas 1 --name nome_do_servico -p 8080: 3000 

nome_da_imagem – Cria um serviço no swarm com apenas uma réplica com a porta interna

3000 mapeada para a porta 8080.

·        docker service inspect --pretty id_servico – Mostra detalhes do serviço de forma 

amigável (pretty)

·        docker service ps id_servico – Exibe os nós que estão rodando o serviço 

·        docker service scale <SERVICE-ID>=<NUMBER-OF-TASKS> - Escala o serviço para a 

quantidade desejada.

·        docker service rm id_servico – Remove o serviço.

·        docker service update --image nome_imagem nome_servico – Atualiza os serviços com

a nova versão da imagem.

·        docker node update --availability drain nome_do_no – Deixa o nó indisponível para 

executar containers.

·        docker service update --constraint-add node.role==worker id_servico – Restringe 

determinado serviço a rodar apenas em nós worker.

·        docker service update --constraint-add node.id==id_do_no id_servico – Restringe 

determinado serviço a rodar apenas no nó especificado (também pode ser passado

o nome da VM, mas tem que trocar node.id por node.hostname).

·        docker service update --constraint-rm node.role==worker id_servico – Remove a 

restrição do serviço de rodar apenas em nós worker.

·        docker service update --constraint-rm node.id==id_do_no id_servico – Remove a  

restrição do serviço de rodar apenas no nó especificado ( também pode ser passado 

o nome da VM, mas tem que trocar node.id por node.hostname).

Erro VT-x is not available (verr_vmx_no_vmx)

             Hoje vou trazer uma solução para um erro que me deu um trabalhão para encontrar uma solução, o erro VT-x is not available (verr_vmx_no_vmx).

         

          Passei por este erro ao instalar o Docker-Machine na minha máquina com Windows 10 e o VirtualBox, resultando que nenhum dos dois funcionou mais.

 

          1 - Vamos entender o problema:

 

VT-x é a Tecnologia de Virtualização da Intel que permite o processador rodar varios SOs ao mesmo tempo de forma que eles “achem” que estão rodando de forma independente. (tem link sobre isso no final).

 

Bem, até aí, tudo normal, você pode instalar VirtualBox por exemplo e mandar ver. A questão é quando você instala algum programa ou usa alguma funcionalidade que usa o Hyper-v no Windows 10 ele simplesmente “toma” o driver VT-x pra ele e não divide com outros programas, assim, o VirtualBox, por exemplo, para de funcionar. E geralmente habilitamos o Hyper-v pra trabalhar com o Docker. Isso quer dizer que as duas tecnologias Docker podem gerar incompatibilidade entre si dependendo da forma que usadas no Windows.

 

          O que é o Hyper-v? É o sistema de virtualização nativo do Windows 10. (link no final).

 

2 – Solução:

 

Para o caso de o problema ter sido gerado pelo uso do Docker-Machine você pode usar o driver Hyper-v ao invés do VirtualBox para criar as VMs. Veja como aqui: https://docs.docker.com/machine/drivers/hyper-v/

 

Para outros casos, ou quando quiser forçar o uso do VirtualBox com o Docker-Machine você vai precisar ficar habilitando e desabilitando o Hyper-v pela linha de comando e também na tela de ativação/desativação de recursos do windows, e vai precisar reiniciar ao fazer isso.

 

          Com esse comando você desabilita:

 

> bcdedit /set hypervisorlaunchtype off

         

          Com esse você habilita:

 

> bcdedit /set hypervisorlaunchtype on 

ou

> bcdedit /set hypervisorlaunchtype auto

          E depois na tela de recursos do Windows você também habilita/desabilita:

 

          !IMPORTANTE! O Docker está dando a opção de usar o Windows Subsystem Linux - WSL 2 no lugar do Hyper-v, mas essa solução continua usando o Hyper-v por baixo dos panos, veja no link https://docs.docker.com/docker-for-windows/wsl/. Por hoje é isso, espero ter ajudado!

 

Links:

https://www.clubedohardware.com.br/artigos/processadores/tudo-o-que-voc%C3%AA-precisa-saber-sobre-a-tecnologia-de-virtualiza%C3%A7%C3%A3o-da-intel-r34579/

 

https://docs.microsoft.com/pt-br/virtualization/hyper-v-on-windows/about/

 

https://docs.microsoft.com/en-us/archive/blogs/gmarchetti/turning-hyper-v-on-and-off

Principais comandos Docker-Machine

Instalar:

base=https://github.com/docker/machine/releases/download/v0.16.0 && mkdir -p "$HOME/bin" && curl -L $base/docker-machine-Windows-x86_64.exe > "$HOME/bin/docker-machine.exe" && chmod +x "$HOME/bin/docker-machine.exe"
 

Executar o comando no GitBash. Nesta versão do Docker-Machine os comandos precisam ser executados nele.

Principais comandos:

⦁    docker-machine ls  - lista máquinas disponíveis
⦁    docker-machine create --driver virtualbox nome_maquina  -  cria uma máquina virtual. É preciso especificar do driver e o nome da máquina.
⦁    docker-machine ip nome_maquina  -   mostra o ip da máquina criada.
⦁    nome_maquina  start  nome_maquina - starta a máquina.
⦁    nome_maquina  stop  nome_maquina  -  para a máquina.
⦁    nome_maquina  restart  nome_maquina - restarta a máquina.
⦁    nome_maquina  ssh  nome_maquina  -  acessa a máquina.
⦁    nome_maquina  inspect  nome_maquina  -  mostra configurações da máquina.
⦁    nome_maquina  status  nome_maquina  - exibe o status da máquina.

Outros:

⦁    nome_maquina  config  nome_maquina.
⦁    nome_maquina  env  nome_maquina.
⦁    nome_maquina  kill  nome_maquina.
⦁    nome_maquina  upgrade  nome_maquina.
⦁    nome_maquina  url  nome_maquina.
⦁    nome_maquina  provision  nome_maquina.

Fonte:
https://docs.docker.com/engine/swarm/swarm-tutorial/
https://docs.docker.com/machine/

Docker Machine

        Quando as pessoas falam em "Docker", normalmente se referem ao Docker Engine, o aplicativo cliente-servidor composto do daemon Docker, uma API REST que especifica interfaces para interagir com o daemon e um cliente de interface de linha de comando (CLI) que se comunica com o daemon (por meio do wrapper REST API). O Docker Engine aceita comandos docker da CLI, como docker run <image>, docker ps para listar contêineres em execução, docker image ls para listar imagens e assim por diante.

 

 

         Docker Machine é uma ferramenta para provisionar e gerenciar seus hosts Dockerizados (hosts com Docker Engine neles). Normalmente, você instala a Máquina Docker em seu sistema local. Docker Machine tem seu próprio cliente docker-machine de linha de comando e o cliente Docker Engine (Docker). Você pode usar o Machine para instalar o Docker Engine em um ou mais sistemas virtuais. Esses sistemas virtuais podem ser locais (como quando você usa a Máquina para instalar e executar o Docker Engine no VirtualBox no Mac ou Windows) ou remotos (como quando você usa a Máquina para provisionar hosts Dockerizados em provedores de nuvem). Os próprios hosts Dockerizados podem ser considerados, e às vezes são chamados de "máquinas" gerenciadas.

 

 

        Resumindo, com o Docker Machine você gerencia um ou vários Docker Engines, onde em cada um você tem suas imagens e gerencia elas através do CLI. Quando falamos em Docker estamos em um nível mais próximo do desenvolvimento (subir aplicações e gerenciá-las), quando falamos em Docker Machine estamos mais próximo da infra (prover máquinas para as equipes subirem e gerenciarem suas aplicações).  Obs: Não que a infra não esteja envolvida no processo de subir aplicações e gerenciá-las, mas com certeza o dev está mais longe de prover máquinas ;)

        O Docker Machine pode ser usado em conjunto com o Docker Swarm, provendo as VMs que o Swarm vai orquestrar.

Fonte: https://docs.docker.com/machine/

Resumo dos principais comandos Docker

 

Resumo dos principais comandos Docker para acesso rápido:

• docker ps - exibe todos os containers em execução no momento, equivale ao "docker container ls". Temos algumas opções interessantes nesse comando:
• -a -> exibe todos os containers, independentemente de estarem em execução ou não.
• -q -> exibe apenas os ids dos contaners.
• -s -> exibe o tamanho do volume.
• docker exec -it nome_ou_id_do_container comando - executa um comando dentro do container de forma interativa (-it). Ex: docker exec -it nome_ou_id bash -> inicia um bash dentro do container especificado.
• docker run -it NOME_DA_IMAGEM - conecta o terminal que estamos utilizando com o do container.
• docker stop ID_CONTAINER - interrompe o container com id em questão. Mata os processos internos.
• docker stop $(docker ps -q) - interrompe todos os containers.
• docker start ID_CONTAINER - inicia o container com id em questão.
• docker pause ID_CONTAINER - pausa o container com id em questão. Não mata os processos internos.
• docker unpause ID_CONTAINER - volta a execução do container pausado com id em questão, com os mesmos processos internos.
• docker start -a -i ID_CONTAINER - inicia o container com id em questão e integra os terminais, além de permitir interação entre ambos. (-a de attach). 
• docker attach ID_CONTAINER - Dessa forma vc acessa um terminal já em execução. Para "desanexar" o container do terminal e ele continuar em background use CTRL+P,  CTRL+Q.

Apagando imagens e contaners

• docker rm ID_CONTAINER - remove o container com id em questão. Se estiver rodando pode usar o --force no final do comando.
• docker container prune - remove todos os containers que estão parados.
• docker rmi NOME_DA_IMAGEM - remove a imagem passada como parâmetro.
• docker container prune - remove todos os containers parados.
• docker images prune -a - remove todas as imagens não ligadas a containers.

Portas e variáveis de ambiente

• docker run -d -P --name NOME dockersamples/static-site - ao executar, dá um nome ao container(--name). A opção -d é de "detached", para que o terminal não fique preso no container. O -P (maiúsculo) atrela as portas internas do container à portas aleatórias na minha máquina local para poder acessar.
• docker run -d -p 12345:80 dockersamples/static-site - define uma porta específica da nossa máquina (12345) para ser atribuída à porta 80 do container.
• docker port ID_CONTAINER - mostra as portas mapeadas.
•  docker run -d -P -e AUTHOR="Fulano" dockersamples/static-site - o -e define uma variável de ambiente AUTHOR com o valor Fulano no container criado. (Neste caso, a imagem usada espera o valor da variável de ambiente.)

Anexando DISCO(Volume)

• docker run -v "[CAMINHO_VOLUME_LOCAL]:CAMINHO_VOLUME_CONTAINER" -w /var/www NOME_DA_IMAGEM - cria um container com volume (-v) no respectivo caminho do container, caso seja especificado um caminho local monta o volume local no volume do container. O -w especifica o diretório que o Docker vai iniciar o container, muito útil para quando se precisa executar certos comandos ao iniciar um servidor por exemplo.
• docker run --mount type=bind,source=[CAMINHO_VOLUME_LOCAL], target=[CAMINHO_VOLUME_CONTAINER] NOME_DA_IMAGEM - cria um container com um volume usando o mount. Essa forma faz um bind do contaner para um local da nossa maquina.
• docker volume create NOME_DO_VOLUME - cria um volume gerenciado pelo Docker. É parecido com associar uma pasta diretamente ao contaner, mas assim ele fica salvo em um lugar específico do Docker(dentro de /var/lib/docker/volumes) e pode ser trabalhado com alguns comandos do docker. 
• docker volume ls - retorna a lista de volumes criados.
• docker run --mount source=[NOME_DO_VOLUME], target=[CAMINHO_VOLUME_CONTAINER] NOME_DA_IMAGEM - cria o contaner com o volume gerenciado, note que nesse caso o type não precisou ser especificado, apenas o nome do volume gerenciado e o destino.
• docker run --tmpfs=CAMINHO/NOME_DA_PASTA - cria pastas temporárias no volume. Algumas aplicações podem fazer bastante uso de pastas temporárias. Funciona com Linux apenas.

Informações

• docker inspect ID_CONTAINER - retorna diversas informações sobre o container.
• docker history ID_CONTAINER - retorna as camadas do container.

Build e publicação

• docker build -f Dockerfile .  - cria uma imagem a partir de um Dockerfile passando o diretório atual (".").
• docker build -f CAMINHO_DOCKERFILE/Dockerfile -t NOME_USUARIO/NOME_IMAGEM .  - constrói e nomeia uma imagem não-oficial informando o caminho para o Dockerfile. O ponto (".") indica o caminho do Dockerfile (diretório atual no caso).
• docker login - inicia o processo de login no Docker Hub.
• docker push NOME_USUARIO/NOME_IMAGEM:versao - envia a imagem criada para o Docker Hub.
• docker pull NOME_USUARIO/NOME_IMAGEM - baixa a imagem desejada do Docker Hub.
• docker tag NOME_USUARIO/NOME_IMAGEM:versao NOVO_NOME_USU/NOVO_NOME_IMG:versao - muda o nome da imagem, isso pode ser necessário para fazer o upload de imagens no repositório.

Rede

• docker network ls - mostra as redes disponíveis. Embora já exista uma rede bridge, para termos controle somos obrigados a criar a nossa.
• docker network create --driver bridge NOME_DA_REDE - cria uma rede especificando o driver desejado.
• docker run -it --name NOME_CONTAINER --network NOME_DA_REDE NOME_IMAGEM - cria um container especificando seu nome e qual rede deverá ser usada. Quando uma rede é usada e o container tem um nome, o Docker se encarrega de fazer o DNS entre os nós da rede, podendo assim chamarmos as máquinas pelos nomes atribuídos.
• hostname -i - mostra o ip atribuído ao container pelo docker (funciona apenas dentro do container).

Docker Compose

• docker-compose build - Realiza o build dos serviços relacionados ao arquivo docker-compose.yml, assim como verifica a sua sintaxe.
• docker-compose up -d - Sobe todos os containers relacionados ao docker-compose, desde que o build já tenha sido executado.
• docker-compose down - Para todos os serviços em execução que estejam relacionados ao arquivo docker-compose.yml.
• docker-compose ps - lista os serviços que estão rodando.

Atenção! Nas versões mais novas foi retirado o hífen ("-") entre as palavras "docker  compose" nos comandos. 

Exemplo de arquivo docker-compose: docker-compose.yml

OBS: para acessar as máquinas caso esteja usando o Docker Tool Box ao invés do Docker for Windows é preciso ver o IP da máquina. Isso pode ser feito com o comando: docker-machine ip.

OBS2: $docker ps -q  retorna os ids dos containers.