Dica rápida de como limpar o cache do Squid no PfSense 2.3.x. (versão que foi testada)
Obs: Antes de começar, veja qual é o proprietário e o grupo do diretório /var/squid/cache, pois será dada a permissão novamente a eles.

 

1 – Pare o serviço do Squid

/usr/local/etc/rc.d/squid.sh stop

 

2 – Remova o diretório do cache do squid e depois crie novamente

rm -rf /var/squid/cache/
mkdir -p /var/squid/cache/

 

3 – Altere o proprietário e o grupo para que estavam antes de apagar os diretórios:

chown proxy:proxy /var/squid/cache/
ou
chown squid:squid /var/squid/cache/

 

4 – Altere a permissão para 750:

chmod 750 /var/squid/cache/

 

5 – Reinicie o Squid:

squid -z
/usr/local/etc/rc.d/squid.sh start

Ao som de: Mamonas Assassinas – 1406

Linux é mais fácil que muita gente imagina. E essa simplicidade se torna uma ferramenta poderosa quando usada da forma certa.
Assim que comecei a usar o Linux, confesso, que usava essa simplicidade de forma não tão produtiva, pois dava certo, mas achava algumas coisas muito trabalhosas. Com o passar do tempo, fui aprendendo algumas formas mais efetivas de usar essas ferramentas.

O intuito desse post é passar algumas dicas que me ajudaram a melhorar a minha produtividade com o Linux. Todas as dicas são básicas, mas que economizam tempo e paciência.

Programas Básicos:

apt

Sei que muita gente é acostumada ao “apt-get” e acha que o “apt” é a mesma coisa, porém o “apt” vem com mais melhorias em seu código e é muito mais organizado para o usuário.

vim

Assim que você começa a usá-lo, não entende o porque as pessoas usam tanto. Até pra sair é “complicado”, tendo que digitar “:wq” para sair e salvar. Porém, algumas funcionalidades o fazem ser “amado” por tantos. Mais a frente vou colocar alguns comandos.

sl

Apenas instalem e nunca mais errem um list! Ou não!

htop

O caso do “htop” é semelhante ao “apt x apt-get”, onde seria “top x htop”. Nesse caso, a diferença é mais visível, pois a organização e as cores do htop dão uma organização melhor que a do “top”

iftop

É o “htop” para placas de redes.

iotop

É o “htop” de I/O de disco.

locate (ou mlocate)

O locate serve para pesquisar um arquivo dentro do sistema. Sim, já existe o “find”, que abordo mais a frente também, mas o locate torna a busca mais rápida, pois ele armazena a busca em um arquivo. Estando tudo indexado em um arquivo, o locate vai fazer a busca nesse arquivo e não no Hd todo, assim sendo mais rápido. Para atualizar esse arquivo basta usar o comando “updatedb”. Ele já vem por padrão no RHEL/Centos, mas na família Debian basta um “apt install mlocate”.

terminator

Depois que descobri esse emulador de terminal, consigo ter uma organização das telas dos terminais muito melhor. A forma que ele divide as telas ajuda bastante para deixar o trabalho mais efetivo, fora a sua customização.

Comandos Básicos:

Passado os programas básico (sim, lista pequena e quase óbvia), dicas de como costumo usar alguns comandos.

ps fuxa

Essa dica aprendi com o Mestre Pedro Veríssimo. O “fuxa” mostra o ps com usuário, PID, %cpu, %mem, TTY, horário do início do processo, o tempo desse processo e o comando no formato de árvore. Para saber o que cada argumento faz, leia o manual (man ps). Tente combinações que você consiga gerenciar melhor os processos rodando nos seus sistemas.

ss -a

O netstat está obsoleto a alguns anos, então essa dica é mais uma atualização. Você pode ler sobre isso nessa reportagem do site Linux Descomplicado. Sobre o assunto, estou criando coragem (e amadurecendo as ideias) para abordar isso de uma forma mais completa. “Manter velhos hábitos, mas que eu sei o que estou fazendo e meu sistemas fica estável” x “Me atualizar, utilizando novas ferramentas, aprendendo novas maneiras de gerir os sistemas, mas que não sei como é o comportamento a longo prazo”.

cd –

Comando básico que muita (mesmo) gente ignora. Serve para voltar ao diretório anterior que você estava. Favor não confundir com o “cd ..” que sobe um diretório. Exemplo: se vocês estava em “/etc/network/interfaces.d/” e foi para “/var/log/”, ao digitar “cd -” você “volta” para “/etc/network/interfaces.d/”. Caso o comando fosse “cd ..” você subiria um nível, indo para “/var/”.

cd ~

Comando que faz você voltar para o home do atual usuário. Se estiver em “/etc/network/interfaces.d/” e digitar “cd ~”, vou para “/home/bruno/”

sudo !!

Já aconteceu de você usar um comando “gigante” e quando apertou “Enter” viu que esqueceu o “sudo” no começo? Eu sei a raiva que isso gera. Aí você, no modo mais “prático”, usa a seta para cima, depois home, depois digita sudo e enter novamente. Não é isso? Era! Basta “sudo !!” e o último comando será executado como se o sudo estivesse no começo. Testa aí.

ctrl + r

Outra do Mestre Pedro Veríssimo. É uma busca dentro do history. Você vai digitando a busca e ele já mostra o comando, bastando um simples “Enter”. E cada vez que usa a combinação ctrl + r enquanto está buscando, ele vai mostrando outros resultados. Nada mais de “history | grep” quando se sabe o que quer procurar, certo?

history + !número

Mesmo com a dica acima, o history é importante. A busca serve pra quando você lembra o que foi digitado, mas e quando não se lembra? history, claro. Aí você acha o que quer, vai selecionar, copiar (ctrl + insert) e depois colar (shift + insert), né? Não mais. Digamos que o comando que você queira está listado como o 149, basta digitar !149 e o comando será executado.

Outras Dicas:

Abaixo alguns comandos precisei usar para situações diversas.

Localizar um tipo de arquivo e a partir de um certo tamanho.

Como assim? Preciso encontrar todos meus vídeos no formato AVI e com mais de 700MB:

find /home/bruno/Vídeos -type f -name “*.avi” -size “+700M” -exec ls -lah {} \;

Mas o segredo é tentar outras combinações como exemplo: arquivos maiores que 100Mb, mas menores que 200Mb:

find /home/bruno/Vídeos -type f -name “*.avi” -size “+100M” -size “-200M” -exec ls -lah {} \;

Dica boa pra quem ainda tem aquelas fotos com o nome “dsc000…”, só colocar o -iname

 

Trabalhando com diretórios em sequência.

Se você já fez “mkdir pasta01/ pasta02/ pasta03/ pasta04/”, você conseguiu o que queria, mas e se for 50 pastas? Vai fazer um shell script com alguma estrutura de laço para repetir até o 50? Pode ser, mas também dá um trabalho. E que tal um comando só?

mkdir -p /home/bruno/pasta{1..50}

Massa, né? E se dentro dessas pastas você tenha que criar outras 10 pastas?

mkdir -p /home/bruno/pasta{1..50}/subpastas{1..10}

Agora sim, muito massa. Mas não se limite aí, pois esse comando não é exclusivo do mkdir, muito pelo contrário. Qualquer comando que trabalhe com os diretórios e arquivos, aceita esses argumentos. Um bom exemplo é apagar essas 50 pastas

rm -rf /home/bruno/pasta{1..50}

 

Criando um “Alias” da maneira certa.

Já vi muitos “tutoriais” ensinando a criar tutorial da forma certa: alias ll=’ls -lahF’, por exemplo. Mas na hora de deixar isso permanente, muita gente criar um script pra iniciar junto com o sistema e assim atribuir esse alias. Só que no linux existe um arquivos pra isso e nele já existe alguns alias e até com exemplo. Basta editar (usando o vim, né?) o arquivo .bashrc que fica no diretório home do seu usuários:

vim ~/.bashrc

Depois só salvar, fechar o terminator (claro!) e abrir novamente. o “ll” foi exemplo, pois algumas distribuições já vem com esse alias, mas você pode adicionar qualquer alias nesse arquivo. Exemplo para atualização com o usuário root:

alias atualizar=”apt update && apt -y upgrade”

Usando melhor o VIM

O VIM tem milhões de atalhos, que você pode conferir alguns aqui, mas os mais básicos parecem ser os mais ignorados:

gg = Início da primeira linha do arquivo
G = Início da última linha do arquivo
yy = Copia a linha atual do cursor
y⇑ = Copia a linha do cursor mais a linha acima
y⇓ = Copia a linha do cursor mais a linha abaixo
y20⇑ = Copia a linha do cursor mais as 20 linha acima
y20⇓ = Copia a linha do cursor mais as 20 linha abaixo
p = Cola a linha abaixo da posição do cursor
P = Cola a linha acima da posição do cursor
dd = Apaga a linha atual do cursor
d⇑ = Apaga a linha do cursor mais a linha acima
d⇓ = Apaga a linha do cursor mais a linha abaixo
d20⇑ = Apaga a linha do cursor mais as 20 linha acima
d20⇓ = Apaga a linha do cursor mais as 20 linha abaixo
u = Desfaz o último comando

Se o seu terminator (né?) está com o fundo preto, diga ao VIM isso para que ele possa mostrar tudo nas cores certas.

:set backgroud=dark

Quando se faz uma busca dentro do VIM (/termo), há algumas opções:
N = Busca o próximo termo acima da posição atual do cursor
n = Busca o próximo termo abaixo da posição atual do cursor

Para realçar o termo que foi buscado no texto:

:set hlsearch

E para remover esse realce da busca:

:nohlsearch

 

Substituição dentro do VIM

Caso queira substituir um dentro da linha onde o cursor está posicionado, basta fazer:

:s/foo/bar/g

No nosso caso, onde tiver “foo” na linha atual, será substituído por “bar”.
Caso queira no documento todo, basta adicionar % no inicio:

:%s/foo/bar/g

 

Como disse no começo, são dicas básicas, mas que me ajudam muito e espero que ajude mais pessoas.
Vou postar os sites que descobri alguns desses comandos e que (alguns) estão mais completos em suas explicações e com outros exemplos:

https://debian-handbook.info/browse/pt-BR/stable/index.html
https://www.vivaolinux.com.br/artigo/Diario-de-um-SysAdmin-1-Truques-Macetes-Atalhos-e-Comandos
https://www.vivaolinux.com.br/artigo/Diario-de-um-SysAdmin-2-Truques-Macetes-Atalhos-e-Comandos
http://michael.peopleofhonoronly.com/vim/vim_cheat_sheet_for_programmers_colorblind.png
http://vim.wikia.com/wiki/Vim_Tips_Wiki 

Ao som de: Dream Theater – Erotomania/Voices/The Silent Man (A Mind Beside Itself) – Live Scenes from New York 

O Docker Compose é uma ferramenta para executar aplicações multi-containers, conforme a documentação do site oficial do Docker (https://docs.docker.com/compose/overview/).

Imagine que você tem 4 Dockerfiles, um para cada aplicação que irá usar um container diferente. Você teria que “rodar” os 4 Dockerfiles para subir essas aplicações. Com o Docker Compose você define tudo isso em um único arquivo, o docker-compose.yml, ou seja, você cria e inicia todos os seus serviços com a configuração que você definiu para cada serviço com um único comando.

Para fazer a instalação do Docker Compose é necessário fazer o download no Github oficial do docker compose: https://github.com/docker/compose/releases . No momento dessa postagem, a versão mais atual é a v1.13.0

O comando para instalar/atualizar para essa versão é:

# curl -L https://github.com/docker/compose/releases/download/1.13.0/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

# chmod +x /usr/local/bin/docker-compose

 

Depois de instalado, como exemplo, vamos fazer um docker-compose.yml que irá subir 2 containers: Um container com o MySQL 5.7 e o outro container com o WordPress mais atual disponível no Docker Hub. Vamos criar um arquivo .env com as variáveis utilizadas nas configurações desses dois serviços. Lembre-se de criar um diretório para esse dois arquivos.

Nome do arquivo: docker-compose.yml

 

version: ‘3’

services:
db:
image: mysql:5.7
volumes:
– db_data:/var/lib/mysql
restart: always
env_file:
– .env
wordpress:

    depends_on:
– db
image: wordpress:latest
ports:
– “8000:80”
restart: always
env_file:
– .env
volumes:
db_data:

 

Agora vamos criar o arquivo com as variáveis de ambiente dentro do arquivo .env

Nome do arquivo: .env

#Variáveis MYSQL
MYSQL_ROOT_PASSWORD=wordpress
MYSQL_DATABASE=wordpress
MYSQL_USER=wordpress
MYSQL_PASSWORD=wordpress

#Variáveis WORDPRESS
WORDPRESS_DB_HOST=db:3306
WORDPRESS_DB_PASSWORD=wordpress

 

Com os dois arquivos prontos, vamos executar o docker compose:

# docker-compose up -d

 

Esse comando executará o arquivo docker-compose, baixar as imagens base, subir dois containers, um com o wordpress e outro com mysql.

A imagem abaixo é um resumo do que foi feito até agora com o Docker Compose e verificando se as imagens e containers estão funcionando.

 


Agora vamos detalhar o que foi usado no Docker Compose acima.

  • VERSION: é onde definimos qual a versão do Docker Compose File que estamos usando. A versão mais atual é a versão 3;
  • SERVICES: é o nome do serviços que vamos criar. Serve para diferenciar quais containers estarão no docker-compose.yml;
  • IMAGE: Determina imagem será usada como base para a criação do container. Semelhante ao FROM do Dockerfile;
  • VOLUME: Faz a montagem dos volumes no container;
  • RESTART: Determina quando o container será reiniciado. No nosso caso, será sempre reiniciado independente do status da saída do container. Para ler sobre as outras opções, clique aqui para ler ir ao Docker Docs.
  • ENV_FILE: Informa que há um arquivo com as variáveis de ambiente que serão usadas nos serviços executados nos containers;
  • DEPENDS_ON: Informa a ordem de dependência dos containers. Por exemplo, o container do wordpress só será iniciado após a criação do container do banco de dados;
  • PORTS: Expõe as portas do host e do container, em ordem;

Outras opções para utilização no docker-compose.yml:

  • BUILD: São opções para aplicar no momento da compilação do compose. Também é possível definir um diretório e compilar os arquivos dentro desse diretório, incluindo Dockerfiles;
  • COMMAND: Semelhante ao CMD do Dockerfile, executa um comando dentro do container;
  • CONTAINER_NAME: Informa o nome do container;
  • DNS: Informa o endereço do servidor DNS;
  • DNS_SEARCH: Informa o Search Domain;
  • DOCKERFILE: Deve ser usado no BUILD para informar a utilização de um Dockerfile;
  • ENTRYPOINT: Informa qual o processo principal do container;
  • ENVIRONMENT: Adiciona variáveis de ambiente. Semelhante ao ENV_FILE, mas sem criar o arquivo .env;
  • EXPOSE: Expõe a porta do container;
  • EXTERNAL_LINKS: Cria links com containers criados fora do arquivo do Docker Compose;
  • EXTRA_HOSTS: Adiciona o mapeamento de hostnames dentro do arquivo /etc/hosts do container;
  • HEALTHCHECK: Define como será testado o estado do container. É preciso determinar o teste que será realizado, o período, o timeout da resposta do teste e o número de tentativas;
  • LABELS: Adiciona informações de metadados no container;
  • LINKS: Cria links com containers que estão dentro do Docker Compose;
  • LOGGING: Configura os logs para um serviço de logs;
  • NETWORK_MODE: Define qual o modo de rede o container irá usar;
  • SYSCTLS: Configura informações relacionadas no Kernel para o container;

Para uma relação completa de todos os argumentos e como utilizá-los, basta ir à página oficial da documentação do docker.

Espero que tenham gostado das postagens e em breve postarei mais informações sobre Docker.

Ao som de: Primus – Wynona’s Big Brown Beaver

Até agora explicamos como o Docker funciona, como instalar, criar um container e administrá-lo. Agora veremos como colocar todas as informações de uma imagem em um único arquivo chamado Dockerfile.

 

Vamos fazer uma imagem para subir um container com o Debian 8.7 e instalar o NGINX.
Primeiramente devemos criar, no host Docker, um diretório onde ficará esse Dockerfile.

cd ~

mkdir Docker && cd Docker && mkdir Nginx && cd Nginx


Após isso, vamos criar um arquivo chamado Dockerfile. Atentar para a grafia com a primeira letra maiúscula. 
Dentro desse arquivo, vamos colocar as seguintes informações:

 

FROM debian:8.7

MAINTAINER contato@161.35.238.43

RUN apt-get update && apt-get install -y nginx

EXPOSE 80

 

Ao colocar essa informação, salve e feche o arquivo. Feito isso, vamos agora executar o Dockerfile com o seguinte comando:

# docker build .

O Docker Build não trabalha com o caminho do arquivo, apenas com o seu diretório, então é necessário informar o caminho do diretório ou, no nosso caso, como estamos no diretório onde se localiza o Dockerfile, apenas um ponto para identificar que o Dockerfile está no diretório atual.

Caso todas as informações estejam corretas, sua imagem será criada e podemos atestar isso com o “docker images”.

 

 

A imagem está criada, mas sem o REPOSITORY e a TAG, pois não repassamos essa informação. Caso queira preencher os campos, basta usar o parâmetro “-t”.

# docker build -t brunoizidorio/nginx:1.0

Utilizamos a nomenclatura repositório/nome e tag. Agora vamos detalhar o nosso primeiro Dockerfile:

  • O Dockerfile funciona no formato: INSTRUÇÃO argumento.
  • O campo FROM é o nome da imagem que utilizamos, nesse caso o Debian 8.7.
  • MAINTAINER é a informação de quem criou o Dockerfile.
  • RUN são os comandos que queremos executar na imagem que escolhemos. Aqui informamos a instalação do Nginx. Lembre-se de sempre colocar o parâmetro para aceitar automaticamente a instalação, caso contrário o Dockerfile apresentará erro, pois estará esperando uma interação.
  • Como o Nginx funciona na porta 80, vamos expor essa porta do container usando o EXPOSE.

 

O primeiro argumento do Dockerfile deve ser sempre o FROM, seguido da imagem e versão que será utilizada. Caso não seja informada a versão, o Docker vai procurar a mais atual do seu repositório oficial. Abaixo, outros argumento utilizados no Dockerfile:

  • MAINTAINER: quem escreve o dockerfile;
    Ex: MAINTAINER contato@161.35.238.43
  • RUN: executa os comandos dentro do container;
    Ex: apt-get update && apt-get install -y nginx
  • ADD: adiciona arquivos, diretórios do host ou de uma url para dentro de um diretório do container, mas não funciona com arquivos compactados;
    Ex: ADD arquivo.txt /home/bruno/
  • CMD: informa os parâmetros que serão usados no ENTRYPOINT. Também pode ser utilizado para informar qual comando será executado após a criação do container, mas pode ser sobrescrito caso seja passada algum parâmetro de execução de algum comando na hora de executar o container;
    Ex: CMD [“nginx”, “-g”, “daemon off;”]
  • LABEL: coloca um metadado para o container;
    Ex: LABEL description=”Container do Nginx”
  • COPY: copia arquivos e diretórios do host para dentro de um diretório do container. Funciona com com arquivos compactados;
    Ex: COPY arquivo.txt /home/bruno/
  • ENTRYPOINT: informa qual será a aplicação principal do container, sendo executada após a inicialização do container. Diferente do CMD, não será sobrescrita. Caso a seja finalizada a execução do programa definido no ENTRYPOINT, o container será encerrado;
    Ex: ENTRYPOINT [“nginx”, “-D”, “FOREGROUND”]
  • ENV: cria uma variável de ambiente;
    Ex: meunome=”Bruno Izidório”
  • EXPOSE: expõe a porta informada do container;
    Ex: EXPOSE 80
  • USER: define qual será o usuário padrão para o container. Caso não seja definido, o padrão é o usuário root;
    Ex: USER bruno
  • WORKDIR: determina qual diretório será o padrão ao fazer o login;
    Ex: WORKDIR /home/bruno/downloads
  • VOLUME: permite a criação de um diretório no host onde fica armazenado os dados do container;
    Ex: VOLUME /home/docker/nginx:/usr/share/nginx/html

 

Ao som de The Neal Morse Band – So Far Gone

Esse post é uma continuação direta do anterior, onde foi criado um container baseado em um imagem. Nesse post vamos detalhar mais a utilização das imagens.
Caso não tenha lido, clique aqui: http://161.35.238.43/docker-instalando-o-docker/

 

Para ver as imagens contidas no Docker da sua máquina, basta digitar:

# docker images

 

Irá aparecer uma tela com 5 campos: REPOSITORY, TAG, IMAGE ID, CREATED e SIZE.

  • REPOSITORY é correspondente ao nome da imagem;
  • TAG é a versão da imagem criada;
  • IMAGE ID é o número de identificação que o Docker cria para a sua imagem. Mais a frente iremos ver outros comando onde poderemos informar tanto o nome quanto a ID da imagem;
  • CREATED é a data da criação da imagem;
  • SIZE é o tamanho total da imagem que foi criada.

 

Como dito anteriormente, foi realizado o download de uma imagem para a execução de uma aplicação, hello-world, dentro de um container. Já vimos a imagem, agora é hora de ver o container com o comando:

# docker ps

 

No nosso caso, não irá aparecer nenhum container, apenas os 7 campos de identificação dos containers: CONTAINER ID, IMAGE, COMMAND, CREATED, STATUS, PORTS e NAMES.

  • CONTAINER ID é o número de identificação do container, equivalente ao IMAGE ID do “docker images”;
  • IMAGE informa qual imagem foi utilizada para a criação do container;
  • COMMAND mostra qual é o comando que está em execução no container. Veremos mais informações a frente;
  • CREATED é a data de criação do container;
  • STATUS exibe o status atual do container;
  • PORTS informa as portas do host e do container que foram utilizadas. Também será tratado mais a frente;
  • NAMES informa o nome do container.

Você deve estar se perguntando por que não tem nenhum container se você executou o Hello World. Se ele é um container, ele era para aparecer quando digitou o comando docker ps ou não?


Para responder essa dúvida, vamos utilizar o parâmetro “-a” no comando anterior. Ficará assim:

# docker ps -a

 

Com a inserção do parâmetro “-a”, o docker exibe todos os containers, incluindo os que estão parados ou que já foram finalizados. Com este comando, o container “hello-world” irá aparecer. O que aconteceu é que o container “hello-world” foi criado e logo em seguida, finalizado. Nesse caso específico, esse container serve apenas como teste para ver se o docker está criando os containers normalmente. Então, o docker fez o download da imagem, criou o container, exibiu a tela da nossa primeira imagem e depois foi finalizado.

Para exemplo de como criar um container e deixá-lo funcionando, vamos criar um novo container com o conteúdo do Ubuntu 14.04.

O comando para criação é esse:

# docker run -ti ubuntu:14.04 /bin/bash

 

O docker run já havíamos visto anteriormente, mas há novos argumentos. O “-t” diz ao container que vamos precisar de um terminal. O “-i” que este container será interativo, ou seja, o STDIN ficará ativo. Também identificamos qual imagem e versão utilizamos com o argumento, o ubuntu:14.04. No último argumento estamos informando qual processo queremos que o container inicie, no caso, o Bash.

Assim que digitar o comando, o docker inicialmente vai procurar a imagem localmente, no nosso caso, Ubuntu 14.04. Como não vai encontrar, ele fará o download da imagem oficial no seu repositório (https://hub.docker.com/explore/) e irá criar o container baseado nessa imagem.

Ao terminar a criação do container, o docker já permite interação direta dentro do container. Para verificar a veracidade dessa informação, basta digitar um comando que identifique qual a versão instalada. No caso do Ubuntu 14.04 vamos exibir o arquivo issue.

 

# cat /etc/issue

 

Nesse ponto é importante que você se atente a infraestrutura que foi montada até agora. Caso você esteja executando seu Docker em uma máquina Debian 8, por exemplo, há um outro sistema operacional, o Ubuntu 14.04, funcionando dentro de um container.

Temos um Ubuntu 14.04 funcionando dentro de um container. Este container está sendo executado dentro do Debian 8 e os dois sistemas estão utilizando o mesmo Kernel, neste caso é Kernel do Debian 8 que é onde o Docker está instalado e gerenciando os containers.

Como estamos atualmente dentro do container do Ubuntu, digite “uname -r” e verá que o resultado vai ser o mesmo obtido anteriormente, no momento da verificação da versão do kernel do host.

Para sair do container sem finalizá-lo, segure a tecla Ctrl e digite na ordem a letra P e depois a Q, só aí você pode soltar o Ctrl. Há uma segunda maneira de sair do container, porém essa finaliza o bash, assim, finalizando o container também. O segundo comando é o Ctrl+D. Isso acontece, pois quando informamos o bash na hora da criação da imagem, estamos passando para o Docker que o Bash será o processo principal do container, chamado de entrypoint. Caso o entrypoint seja finalizado, o container também é finalizado.

 

No nosso exemplo, vamos usar o primeiro comando para manter o container ativo. Agora, executar o comando docker ps para ver se o container criado com a imagem do Ubuntu 14.04 está ativo.

docker ps

 

Caso queira acessar novamente um container, basta usar o attach e o seu ID para acessá-lo. Lembre-se, como o número do ID é único, ele irá aparecer diferente no seu ambiente.

# docker attach 5c595a8d4237

 

Na versão 1.13 (hoje renomeada para 17.03) foi foram realizadas mudanças que trouxeram mais organização ao Docker. Esse mesmo “docker attach” pode ser feito através do “docker container attach”. Isso porque foi implementado um submenu para cada função. Abaixo, alguns comandos do submenu container:

  • attach (container ID): Acessa um container ativo;
  • commit: Cria uma imagem baseado no container ativo;
  • create: Cria um novo container, mas sem acessá-lo;
  • exec (container ID): Executa um comando no container sem acessá-lo;
  • inspect (container ID): Mostra todas as informações do container;
  • kill (container ID): Finaliza um ou mais container;
  • ls: Lista todos os containers;
  • pause (container ID): Pausa o container (sério?);
  • port (container ID): Lista as portas usadas no momento da criação do container. Será visto mais a frente;
  • prune: Finaliza todos os containers que não estão sendo usados.
  • rm (container ID): Remove um ou mais container;
  • start (container ID): Inicia um ou mais container;
  • stats (container ID): Mostra o status do container;
  • stop (container ID): Para um ou mais container;

Para ver a lista completa:

# docker container –help

 

No próximo post vou abordar o Dockerfile!

Ao som de: Emerson, Lake & Palmer – Tarkus

No primeiro post falei um pouco sobre o que o Docker é (e o que não é também) e como ele funciona. Recomendo a leitura para não ficar perdido em alguns conceitos que apareceram nesse post e nos seguintes. Clique aqui para ir ao post “O que é Docker?”.

Nesse segundo post, como prometido, um pouco de prática. Vamos fazer a instalação do Docker em um Debian!

Primeiramente, vamos verificar os requisitos de instalação:

  1. O processador deve ser 64bits;
  2. O Kernel do sistema operacional base deve ser igual ou superior a versão 3.10 estável;
  3. O Kernel deve ter suporte à AUFS, Device Mapper, OverlayFS, Cgroups e Namespaces.

 

Caso não saiba qual versão do Kernel do seu sistema, basta digitar o comando no terminal:

# uname -r

 

Em algumas distribuições, o Docker já está no repositório. No nosso caso, vamos usar o Debian como Sistema Operacional Base para fazer a instalação do Docker.

 

Se não souber qual o Debian está usando, digite o comando lsb_release -cs que retornará uma das palavras: Wheezy (para o Debian 7), Jessie (para o Debian 8) ou Stretch (para o Debian 9).

 

Se o retorno que obteve foi Jessie ou Stretch, digite o seguinte comando:

# sudo apt-get -y install apt-transport-https ca-certificates curl software-properties-common

 

Caso tenha aparecido Wheezy:

# sudo apt-get -y install apt-transport-https ca-certificates curl python-software-properties

 

Para as duas situações acima, os próximos comandos são os mesmos:

# curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add –
# sudo add-apt-repository \
“deb [arch=amd64] https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) \
stable”

# sudo apt-get update

 

Esses comandos irão instalar as dependências necessárias para fazer o download, a adição dos repositórios oficiais e atualização desses repositórios.

Observação: Se estiver usando o Wheezy e apresentar erro quando for atualizar o repositório, altere o arquivo /etc/apt/sources.list apagando a linha que contém essa informação:
deb-src [arch=amd64] https://download.docker.com/linux/debian wheezy stable

 

Agora basta fazer a instalação do docker-ce (O Docker CE, Community Edition, é a versão gratuita do docker) utilizando nosso querido APT-GET:

# sudo apt-get -y install docker-ce

 

O sistema operacional irá instalar a versão mais nova do docker. No momento dessa postagem o Docker está contando as versões pelo Ano.Mês, no caso a versão atual é a 17.05.

 

Agora vamos verificar se já foi feita a instalação normalmente e se é possível criar um container. Após o término da instalação, vamos digitar no terminal:

# docker run hello-world

 

Esse comando irá criar um container, com uma imagem personalizada, com a frase mais conhecida pelos estudantes de programação (com uma pequena variação): Hello World.

 

 

Caso tenha aparecido um texto igual a da imagem acima, você já criou o seu primeiro container!

Com esse comando o Docker verificou se já existia o container Hello-world. Como não existia, pois acabamos de fazer a instalação, o próprio Docker fez o download da imagem e depois criou o container utilizando, automaticamente, essa imagem. Mágico, não?

 

O objetivo desse post era abordar apenas a instalação do Docker-ce e verificar se a instalação ocorreu normalmente. Caso queira fazer a instalação do Docker em outros sistemas operacionais, vá a página oficial do Docker para as instruções de cada sistema operacional. Clique aqui para ir direto à pagina.

 

Ao som de Dream Theater – In The Name of God

Docker

Docker é uma plataforma, desenvolvida em GO, de código aberto para a execução de programas utilizando a técnica de containers.

Caso já tenha ouvido falar de Docker, deve ter observado que o assunto é bem extenso e isso pode ocasionar algum mal entendidos sobre a forma que o Docker trabalha. Para evitar algumas confusões com todas essas informações, vamos falar um pouco sobre o que o Docker não é! Para início, o Docker não é um virtualizador comum, ele não trabalha com Virtualização Total e Paravirtualização. Muitos tentam associar o Docker a estes termos assim que passam a ter um primeiro contato com a ferramenta.

A Virtualização Total simula um hardware completo e dedicado a VM, o S.O não sabe que está sendo virtualizado. Já na Paravirtualização ocorre o oposto, não há hardware completo e dedicado emulado, o S.O tem consciência de que está sendo virtualizado e o seu Kernel já é voltado para trabalhar desta forma, interagindo de forma harmoniosa com a camada Hypervisor.

O Hypervisor pode ser visto como uma camada de software em cima do hardware ou em cima de um S.O que está sobre o hardware. Ele é o responsável pelo gerenciamento das VMs, também controla o acesso aos recursos do Hardware real solicitados pelos S.Os residentes nas VMs.

Passada essas informações iniciais, vamos entender a diferença entre a virtualização comum e a utilização de containers. Na virtualização comum, o S.O convidado possui seu próprio Kernel. Isso não acontece no Docker, pois ele utiliza o Kernel do S.O instalado na máquina física. O Docker utiliza a técnica de containers e estes só carregam aquilo que é necessário para o seu funcionamento. Eles não são Máquinas Virtuais, eles são, simplesmente, containers.

Como forma de exemplo, podemos associar um container a um envelope, onde dentro desse envelope está o espaço de trabalho. Um container é o espaço de trabalho, onde se dá a execução de uma aplicação, por exemplo. A grosso modo, o container isola o processo e as suas dependências dentro de um espaço sem a necessidade de um novo sistema operacional completo para a execução desse processo.

Essa ideia de container não é nova, porém ganhou mais notoriedade com a popularização do Docker em 2015. Essa ideia, de forma bem simples, começou no Unix com o chroot e aos poucos foi se atualizando, passando pelo Jails no Freebsd e Solaris Zones da Sun, por exemplo. Antes do Docker, a plataforma mais conhecida era a LXC, criada em 2008, que era uma melhoria do chroot.

A imagem acima exemplifica bem essa ideia. Na esquerda, um exemplo de Infraestrutura baseada em virtualização comum utilizando a camada Hypervisor. Para a execução das aplicações é necessário um sistema operacional, depois a camada Hypervisor, um outro sistema operacional, porém virtualizado com as bibliotecas e dependências instaladas e só depois a execução da aplicação.

Com o Docker, algumas dessas camadas são eliminadas. Há o sistema operacional base, a Docker Engine, as bibliotecas e dependências, e o container com a aplicação. A camada Hypervisor dá lugar ao Docker Engine que permite que o Kernel seja acessado diretamente pelas aplicações, assim eliminando a necessidade de um sistema operacional para cada aplicação e compartilhando um único Kernel.
Resumindo: com o Hypervisor um sistema operacional completo é virtualizado para poder executar a aplicação. Já o Docker executa a aplicação sem a necessidade de um sistema operacional completo e aproveitando o Kernel do sistema operacional já instalado, sem a necessidade de criar outro sistema operacional de forma virtualizada. Ou seja, com container é possível virtualizar a nível de S.O, iniciando-o como um “processo”.

 

Esse foi o primeiro post sobre Docker e como você pode observar, tem muita informação nova e muitos conceitos. Os próximos posts serão mais práticos
Para uma leitura complementar recomendo a documentação do Site Oficial do Docker, o Mundo Docker e o Canal Linux Tips.
Agradecimento ao Will de Souza pela co-participação do post.

Ao som de Death – Symbolic

Nesse segundo exercício vou utilizar o mesmo IP do primeiro exercício (pode ver clicando aqui), porém de /44 para /47 vou utilizar de /47 para /50.

Repito a informação do post anterior: vou primeiro propor o exercício e depois mostrar a forma que eu utilizo para chegar a resolução.

Mais uma vez um agradecimento especial à Professora Silvana Correa

Dado o seguinte IPv6: FDEC:0000:2390:9023:1137:7311:88D4:4D88 /47
a) Transforme o /47 para um /50.
b) Quantas sub-redes são possíveis com essa transformação?
c) Quais são as sub-redes?

Continuar lendo

No post passado vimos um exercício de Sub-redes em IPv4. Neste post vamos ver fazer um exercício de Sub-redes em IPv6. No momento não serão abordadas as novidades e características do IPv6. Isso será assunto para um outro post, porém recomendo a leitura do site ipv6.br para maiores informações.

Assim como no post sobre IPv4, vou primeiro propor o exercício e depois mostrar a forma que eu utilizo para chegar a resolução. Também repete-se a recomendação de experimentar outros IPs e outros CIDRs.

 

Mais uma vez um agradecimento especial à Professora Silvana Correa

 

Dado o seguinte IPv6: FDEC:0000:2390:9023:1137:7311:88D4:4D88 /44
a) Transforme o /44 para um /47.
b) Quantas sub-redes são possíveis com essa transformação?
c) Quais são as sub-redes?

 

Continuar lendo

Como parte da ideia de compartilhar informação, vou deixar um exercício resolvido em IPv4. Não há nada muito complexo, mas é importante saber como resolver um exercício básico, pois há muitos profissionais que configuram redes sem saber como fazer esses cálculos, apenas usando sites ou aplicativos para isso.

O interessante é você tentar resolver primeiro e só depois olhar a resposta com a forma que eu realizo esse tipo de cálculo. Há outros métodos de realizar esse exercício, porém, utilizo esse por achar mais simples e direto. O importante é chegar no resultado correto, independente do métodos.

Tente experimentar com outros IPs e com outros CIDRs.

Aproveitando pra deixar meus agradecimentos às Professoras Silvana Correa e Odecília Barreira pelo conhecimento repassado.
Considerando o IP 200.168.10.66/26, responda:

a) Qual o endereço de rede?
b) Qual o endereço de Broadcast?
c) Qual a máscara de sub-redes?
d) Quantos hosts há nessa rede?
e) Qual o intervalo válido de IPs para essa rede?

 

Continuar lendo