Ir para o conteúdo
ou

Thin-logo

Tela cheia Sugerir um artigo
Rss-feed

Grupo de Usuários Debian da Bahia - GUD/BA

6 de Dezembro de 2009 , por Desconhecido -

Seja bem vind@, se você é um debiano (um baiano que usa debian) faça parte de nossa comunidade!


Criando imagens Docker (Dockerfile)

27 de Março de 2015, por Desconhecido - 0sem comentários ainda

No artigo anterior sobre Docker, eu falei sobre como modificar uma imagem docker usando COMMIT, mas propositalmente não comentei que essa não é a melhor prática :) Evitei tocar nesse assunto para não frustrar o aprendizado, pois é necessário aprender como funciona o COMMIT, com DIFF e afins.

A melhor forma de modificar uma imagem Docker é recriando ela, ou seja, modificando seu Dockerfile, ou criando um Dockerfile com a imagem escolhida como base e nesse artigo falaremos sobre tudo isso.

Dockerfile

Dockerfile é um arquivo, que contém um conjunto de instruções necessárias para se criar uma imagem Docker, ou seja, com posse do Dockerfile de uma determinada imagem, basta modificar o que deseja e recriar a imagem “do zero”, isso pode demorar um pouco mais, mas essa imagem será muito mais “enxuta” e você terá controle total do seu estado, o que seria bem mais difícil no modelo de efetuar commit de um container.

Caso não tenha o Dockerfile, você pode usar uma imagem a sua escolha como base e então criar a sua imagem como uma camada acima.

Sintaxes básicas

FROM : É a imagem base. Normalmente é usada com nome de distribuição (Debian, Ubuntu e afins), pois não precisaremos criar toda estrutura, certo?

MAINTAINER : É onde se especifica o autor da imagem.

RUN : São as instruções que serão executadas para criação da imagem em questão.

ENTRYPOINT : Especifica o que o que será executado ao iniciar o container. Ele age como precedente a sintaxe CMD, ou seja, caso o ENTRYPOINT seja “top”, o CMD pode ser “-b” que nesse caso ele executaria o top em modo batch. Uma vez que o ENTRYPOINT não seja especificado, e um CMD seja usado, o ENTRYPOINT padrão é “/bin/sh -c“.

EXPOSE : Usado para informar qual porta o container docker irá “escutar”. Docker use essa informação para interconexão entre containers, ao utilizar links. EXPOSE não define qual porta será exposta para o hospedeiro ou tornar possível o acesso externo para portas do container em questão. Para expor essas portas utilize em tempo de inicialização da imagem a flag -p ou -P.

Para explicação mais exaustiva das sintaxes já explanadas e outras novas, acesse essa documentação.

Exemplo

Crie uma pasta com o comando abaixo:

# mkdir nginx

Entre nessa pasta:

# cd nginx

E então crie um arquivo chamado “Dockerfile” com o seguinte conteúdo:

FROM debian
MAINTAINER Rafael Gomes <gomex@riseup.net>
RUN apt-get update
RUN apt-get install -y nginx
ENTRYPOINT ["/usr/sbin/nginx"]
EXPOSE 80

Com esse Dockerfile, temos:

  • Uma imagem com base na imagem do Debian, ou seja, não precisamos nos preocupar com o sistema básico.
  • O autor dessa imagem sou eu :)
  • Primeiro eu atualizo a base do apt-get e então instalo o nginx.
  • Ao iniciar essa imagem ela executará o nginx automaticamente.
  • A porta exposta para possível interconexão entre containers é a porta 80.

Nesse link tem um ótimo documento explicando as boas práticas na criação de um Dockerfile.

Criando a imagem

Com o Dockerfile preenchido, execute o comando abaixo para criar sua imagem:

# docker build -t gomex/nginx .

No lugar de “gomex” coloque o seu usuário da nuvem pública do docker e no lugar de “nginx” o nome da sua imagem.

Ao terminar, pode efetuar o push para a nuvem pública e assim proporcionar a distribuição da sua imagem:

# docker push gomex/nginx

Pronto! Agora já tem sua imagem prontinha, totalmente “enxuta” e disponível para que outra pessoa possa baixar e utilizar.

Por hoje é só pessoal, logo teremos mais artigos sobre Docker. Fiquem atentos.



Modificando e distribuindo “máquinas” Docker

26 de Março de 2015, por PSL-BA Feeds - 0sem comentários ainda

Como relatei nesse artigo, um dos objetivos do Docker é sua facilidade para distribuição de imagens/”máquinas”, mantendo a sua portabilidade e simplicidade

Nesse texto, vou demonstrar como podemos modificar as imagens, que muitos chamam de máquina, e então distribuir via nuvem pública do Docker.

docker-whales-transparent

Iniciando a máquina

Para modificar uma imagem, precisamos que ela seja iniciada e então teremos a camada que chamados de container. Que é onde as mudanças são aplicadas. Para iniciar a “máquina” usa-se o comando abaixo:

# docker run -d -p 80:80 nginx

Agora vamos obter o número de identificação do container com o comando abaixo:

# docker ps

Modifique a máquina

Execute as modificações que deseja nessa “máquina”. Com o comando abaixo é possível acessar o shell da máquina recém iniciada.

# docker exec -it <id do container> bash

Verifique o que mudou

Para verificar quais arquivos de fato foram modificados nesse container. Execute o comando abaixo:

# docker diff <id do container>

Aplique a mudança

Agora que tem certeza sobre a mudança que será feita. Vamos criar uma nova imagem com base no estado desse container com o comando abaixo:

# docker commit <id do container> gomex/nginx-modificado

Atente que o termo “gomex” é meu usuário previamente registrado na nuvem pública do Docker. E tudo que vem depois da “/” é o nome da imagem que desejo criar. Com o comando abaixo será possível conferir que a máquina informada foi criada:

# docker images

Compartilhe

Agora vamos disponibilizar essa imagem para que outras pessoas possam baixar e usufruir da sua colaboração. Para isso usa-se o comando abaixo:

# docker push gomex/nginx-modificado

Acesse a nuvem pública do Docker e verá que sua imagem estará disponível para quem quiser baixar.

Docker facilitando o trabalho colaborativo.

Docker facilitando o trabalho colaborativo.

Pronto! Por hoje é só :) Aguardem novas postagens sobre o Docker.



Modificando e distribuindo “máquinas” Docker

25 de Março de 2015, por Desconhecido - 0sem comentários ainda

Como relatei nesse artigo, um dos objetivos do Docker é sua facilidade para distribuição de imagens/”máquinas”, mantendo a sua portabilidade e simplicidade

Nesse texto, vou demonstrar como podemos modificar as imagens, que muitos chamam de máquina, e então distribuir via nuvem pública do Docker.

docker-whales-transparent

Iniciando a máquina

Para modificar uma imagem, precisamos que ela seja iniciada e então teremos a camada que chamados de container. Que é onde as mudanças são aplicadas. Para iniciar a “máquina” usa-se o comando abaixo:

# docker run -d -p 80:80 nginx

Agora vamos obter o número de identificação do container com o comando abaixo:

# docker ps

Modifique a máquina

Execute as modificações que deseja nessa “máquina”. Com o comando abaixo é possível acessar o shell da máquina recém iniciada.

# docker exec -it <id do container> bash

Verifique o que mudou

Para verificar quais arquivos de fato foram modificados nesse container. Execute o comando abaixo:

# docker diff <id do container>

Aplique a mudança

Agora que tem certeza sobre a mudança que será feita. Vamos criar uma nova imagem com base no estado desse container com o comando abaixo:

# docker commit <id do container> gomex/nginx-modificado

Atente que o termo “gomex” é meu usuário previamente registrado na nuvem pública do Docker. E tudo que vem depois da “/” é o nome da imagem que desejo criar. Com o comando abaixo será possível conferir que a máquina informada foi criada:

# docker images

Compartilhe

Agora vamos disponibilizar essa imagem para que outras pessoas possam baixar e usufruir da sua colaboração. Para isso usa-se o comando abaixo:

# docker push gomex/nginx-modificado

Acesse a nuvem pública do Docker e verá que sua imagem estará disponível para quem quiser baixar.

Docker facilitando o trabalho colaborativo.

Docker facilitando o trabalho colaborativo.

Pronto! Por hoje é só :) Aguardem novas postagens sobre o Docker.



Docker, infraestrutura simples e rápida

24 de Março de 2015, por Desconhecido - 0sem comentários ainda

O que é Docker

Uma plataforma aberta para desenvolvedores e administradores de sistemas, usada para construir, executar e distribuir máquinas.

Tudo isso é possível por conta da Docker Engine, que é um forma de empacotamento portável, simples e pequena de infraestrutura, que constitui facilmente várias máquinas executando no mesmo kernel, porem isoladas logicamente, usando as tecnologias LXC, AUFS e BTRFS.

Parece uma m&#xe1;quina virtual, n&#xe3;o &#xe9;? Por&#xe9;m &#xe9; diferente!

Parece uma máquina virtual, não é? Porém é diferente!

Continuando sobre o conceito da plataforma Docker, eles disponibiliza também um serviço de Nuvem para armazenar e compartilhar imagens prontas, criadas tanto pela comunidade responsável pelo Docker, como por qualquer outra pessoa interessada, e o melhor, sem custo!

Cada pessoa registrada no serviço tem a possibilidade de criar um número ilimitado de máquinas públicas (todos podem ver e baixar) e apenas uma máquinas privada na conta gratuita.

Imagens e Containers

Uma máquina docker pode ser composta de várias camadas. E essas camadas se dividem em dois tipos; Imagens e Containers.

  • Imagens: Uma vez as máquinas em execução essas camadas são montadas como somente leitura. Elas podem ser compartilhadas por várias máquinas, ou seja, uma vez modificadas afetam todas as máquinas que usam essas imagens.
  • Containers: Essas camadas são montadas como leitura e escrita. É onde de fato estão as modificações da máquina em execução. Toda modificação realizada em uma imagem é feita a partir de um container.
Imagens e containers, perfeita sinergia.

Imagens e containers, perfeita sinergia.

Instalando o Docker

Se você usar Debian Jessie ou superior, não terá problemas. Basta executar o comando abaixo:
# aptitude install docker.io

Caso não utilize GNU/Linux, pode usar o boot2docker.

Conhecendo alguns comandos básicos

Infelizmente o docker ainda não tem uma interface web ou gráfica desktop suportada de forma estável pela sua comunidade oficial, sendo assim falaremos aqui apenas de comandos no shell.

Segue abaixo os comandos mais básicos do docker:

docker pull [nome da imagem]
: Baixar imagem
docker images : Listar imagens
docker run [nome da imagem] : Iniciar a imagem
docker ps  : Listar containers
docker exec [id do container] [comando] : Executa comandos no container

Mais comandos, podem encontrar nesse link.

Instalando uma máquina e executando em 2 minutos

Dois comandos, e o tempo gasto será apenas de download:

# docker pull nginx
# docker run -d -p 80:80 nginx

Pronto! Sua máquina estará funcionando.

O parâmetro -d, informa que a máquina será executada em background e o parâmetro -p informa que toda requisição da porta 80 no ip do hospedeiro, será redirecionado para a porta 80 da máquina que acabou de ser iniciada.

Sem persistência

Lembrando que as mudanças são apenas aplicadas no container, toda vez que desligar a máquina, na verdade você estará desmontando essa camada, e ao iniciar a máquina a partir de uma imagem será criado um novo container, ou seja, terás uma máquina “novinha em folha”.

Para desligar um container em execução, use o comando abaixo:

# docker stop <id do container>

É possível reiniciar um container que foi “desligado”. Usando o comando abaixo:

# docker start <id do container>

Obs: Lembrando que todos os dados de memória RAM serão perdidos, apenas os dados em disco serão armazenados e reutilizados na próxima execução.

Por hoje é só, aguardem novos artigos sobre Docker, pois falaremos sobre modificação de imagens, mapeamento de disco, criação de máquinas “do zero” e outras coisas interessantes sobre o docker.

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



rrg: visualize the require hierarchy in Ruby projects

20 de Março de 2015, por Desconhecido - 0sem comentários ainda

Yesterday I was hacking on some Ruby code and getting a weird error which I thought was caused by mutually recursive require statements (i.e. A requires B, and B requires A). Later I realized that this is not an issue in Ruby, since the intepreter keeps track of what has already been required and will not enter a loop. But during the investigation I came up with something that turned out to be useful.

rrg will read the source code of a Ruby project and generate a graph based on the require statements in the code; nodes represent the source files and an arrow from A to B means that A contains a `require ‘B’` statement.

From the README:

Just run rrg at the root of your project. rrg will parse the code inside lib/, and generate a graph description in the Graphviz format. You can pipe the output to Graphviz directly, or store it in a file and process it to generate an image.

If you call rrgv instead, it will automatically process the graph with Graphviz, generate a PNG image, and open it.

Let’s see some examples. First the classical “analysing itself” example, the require graph for rrg itself:

Not very interesting, since all of the logic is currently in the main binary and not on library code. But 1) when I do the refactorings I want to, there will be more library code and 2) while writing this I implemented also parsing scripts in bin/.

Now chake which is a slightly larger project:

An even larger (but still not that big) project, gem2deb:

Note that these visualizations may not be accurate representations of the actual source code. In Ruby, nothing stops one from implementing class A::B in lib/x/y.rb, but most reasonable code will make sure that filenames and the classes namespaces actually match.

If you are working on a sane codebase, though, visualizing graphs like this helps understand the general structure of the code and perceive possible improvements. The gem2deb graph gave me some ideas already and I didn’t even paid much attention to it yet.