One place for hosting & domains

      CentOS

      Como Instalar e Usar o Docker Compose no CentOS 7


      Introdução

      O Docker é uma ótima ferramenta para automatizar o deployment de aplicações Linux dentro de containers de software, mas para aproveitar realmente ao máximo seu potencial, é melhor se cada componente de sua aplicação for executado em seu próprio container. Para aplicações complexas com muitos componentes, orquestrar todos os containers para iniciar e encerrar juntos (para não mencionar ter que falar uns com os outros) pode rapidamente tornar-se problemático.

      A comunidade Docker apareceu com uma solução popular chamada Fig, que permitia usar um único arquivo YAML para orquestrar todos os containers e configurações do Docker. Isso se tornou tão popular que a equipe do Docker decidiu fazer o Docker Compose com base nos fontes do Fig, que agora está obsoleto. O Docker Compose torna mais fácil para os usuários orquestrarem os processos de containers do Docker, incluindo inicialização, encerramento e configuração de links e volumes dentro de containers.

      Neste tutorial, você instalará a versão mais recente do Docker Compose para ajudá-lo a gerenciar aplicações de vários containers e explorará os comandos básicos do software.

      Conceitos de Docker e Docker Compose

      A utilização do Docker Compose requer uma combinação de vários conceitos diferentes do Docker em um, portanto, antes de começarmos, vamos analisar alguns dos vários conceitos envolvidos. Se você já estiver familiarizado com os conceitos do Docker, como volumes, links e port forwarding, você pode querer ir em frente e pular para a próxima seção.

      Imagens Docker

      Cada container Docker é uma instância local de uma imagem Docker. Você pode pensar em uma imagem Docker como uma instalação completa do Linux. Geralmente, uma instalação mínima contém apenas o mínimo de pacotes necessários para executar a imagem. Essas imagens usam o kernel do sistema host, mas como elas estão rodando dentro de um container Docker e só veem seu próprio sistema de arquivos, é perfeitamente possível executar uma distribuição como o CentOS em um host Ubuntu (ou vice-versa).

      A maioria das imagens Docker é distribuída através do Docker Hub, que é mantido pela equipe do Docker. Os projetos open source mais populares têm uma imagem correspondente carregada no Registro Docker, que você pode usar para fazer o deploy do software. Quando possível, é melhor pegar imagens “oficiais”, pois elas são garantidas pela equipe do Docker e seguem as práticas recomendadas do Docker.

      Comunicação Entre Imagens Docker

      Os containers Docker são isolados da máquina host, o que significa que, por padrão, a máquina host não tem acesso ao sistema de arquivos dentro do container, nem a qualquer meio de comunicação com ele por meio da rede. Isso pode dificultar a configuração e o trabalho com a imagem em execução em um container Docker.

      O Docker tem três maneiras principais de contornar isso. O primeiro e mais comum é fazer com que o Docker especifique variáveis de ambiente que serão definidas dentro do container. O código em execução no container Docker verificará os valores dessas variáveis de ambiente na inicialização e os utilizará para se configurar adequadamente.

      Outro método comumente usado é um Docker data volume. Os volumes Docker vêm em dois tipos – internos e compartilhados.

      Especificar um volume interno significa apenas que, para uma pasta que você especificar para um determinado container Docker, os dados persistirão quando o container for removido. Por exemplo, se você quisesse ter certeza de que seus arquivos de log persistam, você poderia especificar um volume /var/log interno.

      Um volume compartilhado mapeia uma pasta dentro de um container Docker para uma pasta na máquina host. Isso permite que você compartilhe arquivos facilmente entre o container Docker e a máquina host.

      A terceira maneira de se comunicar com um container Docker é pela rede. O Docker permite a comunicação entre diferentes containers por meio de links, bem como o port forwarding ou encaminhamento de portas, permitindo que você encaminhe portas de dentro do container Docker para portas no servidor host. Por exemplo, você pode criar um link para permitir que os containers do WordPress e do MariaDB se comuniquem entre si e usem o encaminhamento de porta para expor o WordPress ao mundo externo, para que os usuários possam se conectar a ele.

      Pré-requisitos

      Para seguir este artigo, você precisará do seguinte:

      Uma vez que estes requisitos estejam atentidos, você estará pronto para seguir adiante.

      Passo 1 — Instalando o Docker Compose

      Para obter a versão mais recente, tome conhecimento dos docs do Docker e instale o Docker Compose a partir do binário no repositório GitHub do Docker.

      Verifique a release atual e se necessário, atualize-a no comando abaixo:

      • sudo curl -L "https://github.com/docker/compose/releases/download/1.23.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

      Em seguida, defina as permissões para tornar o binário executável:

      • sudo chmod +x /usr/local/bin/docker-compose

      Logo após, verifique se a instalação foi bem-sucedida, checando a versão

      Isso imprimirá a versão que você instalou:

      Output

      docker-compose version 1.23.2, build 1110ad01

      Agora que você tem o Docker Compose instalado, você está pronto para executar um exemplo de “Hello World”.

      O registro público do Docker, o Docker Hub, inclui uma imagem simples “Hello World” para demonstração e teste. Ela ilustra a configuração mínima necessária para executar um container usando o Docker Compose: um arquivo YAML que chama uma única imagem.

      Primeiro, crie um diretório para o nosso arquivo YAML:

      Em seguida, mude para o diretório:

      Agora crie o arquivo YAML usando seu editor de texto favorito. Este tutorial usará o vi:

      Entre no modo de inserção, pressionando i, depois coloque o seguinte conteúdo no arquivo:

      docker-compose.yml

      my-test:
        image: hello-world
      

      A primeira linha fará parte do nome do container. A segunda linha especifica qual imagem usar para criar o container. Quando você executar o comando docker-compose up, ele procurará uma imagem local com o nome especificado, hello-world.

      Com isso pronto, pressione ESC para sair do modo de inserção. Digite :x e depois ENTER para salvar e sair do arquivo.

      Para procurar manualmente as imagens no seu sistema, use o comando docker images:

      Quando não há imagens locais, apenas os cabeçalhos das colunas são exibidos:

      Output

      REPOSITORY TAG IMAGE ID CREATED SIZE

      Agora, ainda no diretório ~/hello-world, execute o seguinte comando para criar o container:

      Na primeira vez que executarmos o comando, se não houver uma imagem local chamada hello-world, o Docker Compose vai baixá-la do repositório público do Docker Hub:

      Output

      Pulling my-test (hello-world:)… latest: Pulling from library/hello-world 1b930d010525: Pull complete . . .

      Depois de baixar a imagem, o docker-compose cria um container, anexa e executa o programa hello, que por sua vez confirma que a instalação parece estar funcionando:

      Output

      . . . Creating helloworld_my-test_1… Attaching to helloworld_my-test_1 my-test_1 | my-test_1 | Hello from Docker. my-test_1 | This message shows that your installation appears to be working correctly. my-test_1 | . . .

      Em seguida, imprimirá uma explicação do que ele fez:

      Output

      . . . my-test_1 | To generate this message, Docker took the following steps: my-test_1 | 1. The Docker client contacted the Docker daemon. my-test_1 | 2. The Docker daemon pulled the "hello-world" image from the Docker Hub. my-test_1 | (amd64) my-test_1 | 3. The Docker daemon created a new container from that image which runs the my-test_1 | executable that produces the output you are currently reading. my-test_1 | 4. The Docker daemon streamed that output to the Docker client, which sent it my-test_1 | to your terminal. . . .

      Os containers Docker só são executados enquanto o comando estiver ativo, portanto, assim que o hello terminar a execução, o container finaliza. Conseqüentemente, quando você olha para os processos ativos, os cabeçalhos de coluna aparecerão, mas o container hello-world não será listado porque não está em execução:

      Output

      CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

      Use a flag -a para mostrar todos os containers, não apenas os ativos:

      Output

      CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 50a99a0beebd hello-world "/hello" 3 minutes ago Exited (0) 3 minutes ago hello-world_my-test_1

      Agora que você testou a execução de um container, é possível explorar alguns dos comandos básicos do Docker Compose.

      Passo 3 — Aprendendo os Comandos do Docker Compose

      Para começar com o Docker Compose, esta seção irá examinar os comandos gerais que a ferramenta docker-compose suporta.

      O comando docker-compose funciona em uma base por diretório. Você pode ter vários grupos de containers do Docker em execução em uma máquina — basta criar um diretório para cada container e um arquivo docker-compose.yml para cada diretório.

      Até agora você tem executado o docker-compose up por conta própria, a partir do qual você pode usar o CTRL-C para fechar o container. Isso permite que as mensagens de debug sejam exibidas na janela do terminal. Isso não é o ideal; quando rodando em produção, é mais robusto ter o docker-compose agindo mais como um serviço. Uma maneira simples de fazer isso é adicionar a opção -d quando você fizer um up em sua sessão:

      O docker-compose agora será executado em segundo plano ou background.

      Para mostrar seu grupo de containers Docker (estejam interrompidos ou em execução no momento), use o seguinte comando:

      Se um container for interrompido, o State será listado como Exited, conforme mostrado no exemplo a seguir:

      Output

      Name Command State Ports ------------------------------------------------ hello-world_my-test_1 /hello Exit 0

      Um container em execução mostrará Up:

      Output

      Name Command State Ports --------------------------------------------------------------- nginx_nginx_1 nginx -g daemon off; Up 443/tcp, 80/tcp

      Para parar todos os containers Docker em execução para um grupo de aplicações, digite o seguinte comando no mesmo diretório que o arquivo docker-compose.yml que você usou para iniciar o grupo Docker:

      Nota: docker-compose kill também está disponível se você precisar fechar as coisas de maneira forçada.

      Em alguns casos, os containers Docker armazenarão suas informações antigas em um volume interno. Se você quiser começar do zero, você pode usar o comando rm para excluir totalmente todos os containers que compõem o seu grupo de containers:

      Se você tentar qualquer um desses comandos a partir de um diretório diferente do diretório que contém um container Docker e um arquivo .yml, ele retornará um erro:

      Output

      ERROR: Can't find a suitable configuration file in this directory or any parent. Are you in the right directory? Supported filenames: docker-compose.yml, docker-compose.yaml

      Esta seção abordou o básico sobre como manipular containers com o Docker Compose. Se você precisasse obter maior controle sobre seus containers, você poderia acessar o sistema de arquivos do container e trabalhar a partir de um prompt de comando dentro de seu container, um processo descrito na próxima seção.

      Passo 4 — Acessando o Sistema de Arquivos do Container Docker

      Para trabalhar no prompt de comando dentro de um container e acessar seu sistema de arquivos, você pode usar o comando docker exec.

      O exemplo “Hello World” sai depois de ser executado, portanto, para testar o docker exec, inicie um container que continuará em execução. Para os fins deste tutorial, use a imagem Nginx do Docker Hub.

      Crie um novo diretório chamado nginx e vá até ele:

      Em seguida, crie um arquivo docker-compose.yml em seu novo diretório e abra-o em um editor de texto:

      Em seguida, adicione as seguintes linhas ao arquivo:

      ~/nginx/docker-compose.yml

      nginx:
        image: nginx
      

      Salve o arquivo e saia. Inicie o container Nginx como um processo em background com o seguinte comando:

      O Docker Compose fará o download da imagem Nginx e o container será iniciado em background.

      Agora você precisará do CONTAINER ID para o container. Liste todos os containers que estão em execução com o seguinte comando:

      Você verá algo semelhante ao seguinte:

      Output of `docker ps`

      CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES b86b6699714c nginx "nginx -g 'daemon of…" 20 seconds ago Up 19 seconds 80/tcp nginx_nginx_1

      Se você quisesse fazer uma alteração no sistema de arquivos dentro deste container, você pegaria seu ID (neste exemplo b86b6699714c) e usaria docker exec para iniciar um shell dentro do container:

      • docker exec -it b86b6699714c /bin/bash

      A opção -t abre um terminal, e a opção -i o torna interativo. /bin/bash abre um shell bash para o container em execução.

      Você verá um prompt bash para o container semelhante a:

      root@b86b6699714c:/#
      

      A partir daqui, você pode trabalhar no prompt de comando dentro do seu container. No entanto, lembre-se de que, a menos que você esteja em um diretório salvo como parte de um volume de dados, suas alterações desaparecerão assim que o container for reiniciado. Além disso, lembre-se de que a maioria das imagens Docker é criada com instalações mínimas do Linux, portanto, alguns dos utilitários e ferramentas de linha de comando aos quais você está acostumado podem não estar presentes.

      Conclusão

      Agora você instalou o Docker Compose, testou sua instalação executando um exemplo “Hello World” e explorou alguns comandos básicos.

      Embora o exemplo “Hello World” tenha confirmado sua instalação, a configuração simples não mostra um dos principais benefícios do Docker Compose — a capacidade de ligar e desligar um grupo de containers Docker ao mesmo tempo. Para ver o poder do Docker Compose em ação, confira How To Secure a Containerized Node.js Application with Nginx, Let’s Encrypt, and Docker Compose e How To Configure a Continuous Integration Testing Environment with Docker and Docker Compose on Ubuntu 16.04. Embora estes tutoriais sejam voltados para o Ubuntu 16.04 e 18.04, os passos podem ser adaptados para o CentOS 7.



      Source link

      Como Instalar e Usar o Docker no CentOS 7


      Introdução

      O Docker é um aplicativo que torna simples e fácil executar processos de aplicações em um container, que são como máquinas virtuais, apenas mais portáveis, mais fáceis de usar e mais dependentes do sistema operacional do host. Para uma introdução detalhada aos diferentes componentes de um container Docker, confira O Ecossistema do Docker: Uma Introdução aos Componentes Comuns.

      Existem dois métodos para instalar o Docker no CentOS 7. Um método envolve instalá-lo em uma instalação existente do sistema operacional. O outro envolve lançar um servidor com uma ferramenta chamada Docker Machine que instala automaticamente o Docker nele.

      Neste tutorial, você aprenderá a instalar e usar o Docker em uma instalação existente do CentOS 7.

      Pré-requisitos

      • Um Droplet CentOS de 64-bits
      • Um usuário não-root com privilégios sudo. Um servidor CentOS 7 configurado usando o guia de Configuração Inicial do Servidor com o CentOS 7.

      Nota: O Docker requer uma versão de 64 bits do CentOS 7, bem como uma versão do kernel igual ou maior que 3.10. O Droplet padrão do CentOS 7 de 64 bits atende a esses requisitos.

      Todos os comandos neste tutorial devem ser executados como um usuário não-root. Se o acesso como root for requerido para o comando, ele será precedido pelo sudo. O guia de Configuração Inicial do Servidor com o CentOS 7 explica como adicionar usuários e fornecer a eles o acesso ao sudo.

      Passo 1 — Instalando o Docker

      O pacote de instalação do Docker disponível no repositório oficial do CentOS 7 pode não ser a versão mais recente. Para obter a versão mais recente e melhor, instale o Docker a partir do repositório oficial do Docker. Esta seção mostra como fazer exatamente isso.

      Mas primeiro, vamos atualizar o banco de dados de pacotes:

      • sudo yum check-update

      Agora execute este comando. Ele adicionará o repositório oficial do Docker, baixará a versão mais recente do Docker e a instalará:

      • curl -fsSL https://get.docker.com/ | sh

      Após a conclusão da instalação, inicie o daemon do Docker:

      • sudo systemctl start docker

      Verifique se ele está em execução:

      • sudo systemctl status docker

      A saída deve ser semelhante à seguinte, mostrando que o serviço está ativo e em execução:

      Output
      ● docker.service - Docker Application Container Engine Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled) Active: active (running) since Sun 2016-05-01 06:53:52 CDT; 1 weeks 3 days ago Docs: https://docs.docker.com Main PID: 749 (docker)

      Por fim, certifique-se que ele vai iniciar em todas as reinicializações do servidor:

      • sudo systemctl enable docker

      A instalação do Docker agora oferece não apenas o serviço Docker (daemon), mas também o utilitário de linha de comando docker ou o cliente Docker. Vamos explorar como usar o comando docker mais adiante neste tutorial.

      Passo 2 — Executando Comandos Docker Sem Sudo (Opcional)

      Por padrão, executar o comando docker requer privilégios de root — isto é, você tem que prefixar o comando com sudo. Ele também pode ser executado por um usuário no grupo docker, que é criado automaticamente durante a instalação do Docker. Se você tentar executar o comando docker sem prefixá-lo com sudo ou sem estar no grupo docker, você obterá uma saída como esta:

      Output
      docker: Cannot connect to the Docker daemon. Is the docker daemon running on this host?. See 'docker run --help'.

      Se você quiser evitar digitar sudo sempre que executar o comando docker, adicione seu nome de usuário ao grupo docker:

      • sudo usermod -aG docker $(whoami)

      Você precisará sair do Droplet e voltar como o mesmo usuário para ativar essa mudança.

      Se você precisar adicionar um usuário ao grupo docker no qual você não está logado, declare este username explicitamente usando:

      • sudo usermod -aG docker username

      O restante deste artigo supõe que você esteja executando o comando docker como um usuário do grupo de usuários docker. Se você optar por não fazê-lo, por favor, prefixe os comandos com sudo.

      Passo 3 — Usando o Comando Docker

      Com o Docker instalado e funcionando, agora é a hora de se familiarizar com o utilitário de linha de comando. O uso do docker consiste em passar uma cadeia de opções e subcomandos seguidos por argumentos. A sintaxe assume este formato:

      • docker [option] [command] [arguments]

      Para ver todos os subcomandos disponíveis, digite:

      • docker

      A partir do Docker 1.11.1, a lista completa de subcomandos disponíveis inclui:

      Output
      attach Attach to a running container build Build an image from a Dockerfile commit Create a new image from a container's changes cp Copy files/folders between a container and the local filesystem create Create a new container diff Inspect changes on a container's filesystem events Get real time events from the server exec Run a command in a running container export Export a container's filesystem as a tar archive history Show the history of an image images List images import Import the contents from a tarball to create a filesystem image info Display system-wide information inspect Return low-level information on a container or image kill Kill a running container load Load an image from a tar archive or STDIN login Log in to a Docker registry logout Log out from a Docker registry logs Fetch the logs of a container network Manage Docker networks pause Pause all processes within a container port List port mappings or a specific mapping for the CONTAINER ps List containers pull Pull an image or a repository from a registry push Push an image or a repository to a registry rename Rename a container restart Restart a container rm Remove one or more containers rmi Remove one or more images run Run a command in a new container save Save one or more images to a tar archive search Search the Docker Hub for images start Start one or more stopped containers stats Display a live stream of container(s) resource usage statistics stop Stop a running container tag Tag an image into a repository top Display the running processes of a container unpause Unpause all processes within a container update Update configuration of one or more containers version Show the Docker version information volume Manage Docker volumes wait Block until a container stops, then print its exit code

      Para visualizar as opções disponíveis para um comando específico, digite:

      • docker subcomando-docker --help

      Para visualizar informações de todo o sistema, use:

      • docker info

      Passo 4 — Trabalhando com Imagens Docker

      Os containers Docker são executados a partir de imagens Docker. Por padrão, ele extrai essas imagens do Docker Hub, um registro Docker gerenciado pela Docker, a empresa por trás do projeto Docker. Qualquer pessoa pode criar e hospedar suas imagens no Docker Hub, de modo que a maioria das aplicações e distribuições Linux que você precisa para executar containers Docker tem imagens que estão hospedadas no Docker Hub.

      Para verificar se você pode acessar e baixar imagens do Docker Hub, digite:

      • docker run hello-world

      A saída, que deve incluir o seguinte, deve indicar que o Docker está funcionando corretamente:

      Output
      Hello from Docker. This message shows that your installation appears to be working correctly. …

      Você pode procurar imagens disponíveis no Docker Hub usando o comando docker com o subcomando search. Por exemplo, para procurar a imagem do CentOS, digite:

      • docker search centos

      O script rastreará o Docker Hub e retornará uma listagem de todas as imagens cujo nome corresponde à string de pesquisa. Nesse caso, a saída será semelhante a esta:

      Output
      NAME DESCRIPTION STARS OFFICIAL AUTOMATED centos The official build of CentOS. 2224 [OK] jdeathe/centos-ssh CentOS-6 6.7 x86_64 / CentOS-7 7.2.1511 x8… 22 [OK] jdeathe/centos-ssh-apache-php CentOS-6 6.7 x86_64 / Apache / PHP / PHP M… 17 [OK] million12/centos-supervisor Base CentOS-7 with supervisord launcher, h… 11 [OK] nimmis/java-centos This is docker images of CentOS 7 with dif… 10 [OK] torusware/speedus-centos Always updated official CentOS docker imag… 8 [OK] nickistre/centos-lamp LAMP on centos setup 3 [OK] …

      Na coluna OFFICIAL, o OK indica uma imagem criada e suportada pela empresa por trás do projeto. Depois de identificar a imagem que você gostaria de usar, você pode fazer o download dela para o seu computador usando o subcomando pull, assim:

      • docker pull centos

      Depois que uma imagem foi baixada, você pode então executar um container usando a imagem baixada com o subcomando run. Se uma imagem não tiver sido baixada quando o docker for executado com o subcomando run, o cliente do Docker primeiro fará o download da imagem e, em seguida, executará um container usando-a:

      • docker run centos

      Para ver as imagens que foram baixadas para o seu computador, digite:

      • docker images

      A saída deve ser semelhante ao seguinte:

      [secondary_lable Output]
      REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
      centos              latest              778a53015523        5 weeks ago         196.7 MB
      hello-world         latest              94df4f0ce8a4        2 weeks ago         967 B
      

      Como você verá mais adiante neste tutorial, as imagens que você usa para executar containers podem ser modificadas e usadas para gerar novas imagens, que podem então ser enviadas (push é o termo técnico) para o Docker Hub ou outros registros Docker.

      Passo 5 — Executando um Container Docker

      O container hello-world que você executou na etapa anterior é um exemplo de um container que é executado e sai após a emissão de uma mensagem de teste. Os containers, no entanto, podem ser muito mais úteis do que isso e podem ser interativos. Afinal, eles são semelhantes às máquinas virtuais, apenas mais fáceis de usar.

      Como um exemplo, vamos rodar um container usando a última imagem do CentOS. A combinação das chaves -i e -t fornece a você o acesso interativo ao shell no container:

      • docker run -it centos

      Seu prompt de comando deve mudar para refletir o fato de que você agora está trabalhando dentro do container e deve assumir esta forma:

      Output
      [root@59839a1b7de2 /]#

      Importante: Observe o ID do container no prompt de comando. No exemplo acima, ele é 59839a1b7de2.

      Agora você pode executar qualquer comando dentro do container. Por exemplo, vamos instalar o servidor MariaDB no container em execução. Não há necessidade de prefixar qualquer comando com o sudo, porque você está operando dentro do container com privilégios de root:

      • yum install mariadb-server

      Passo 6 — Fazendo o Commit de Alterações para uma Imagem Docker

      Quando você inicia uma imagem Docker, você pode criar, modificar e excluir arquivos da mesma forma que você faz com uma máquina virtual. As alterações que você fizer serão aplicadas apenas a esse container. Você pode iniciá-lo e pará-lo, mas depois de destruí-lo com o comando docker rm, as alterações serão perdidas para sempre.

      Esta seção lhe mostra como salvar o estado de um container como uma nova imagem Docker.

      Depois de instalar o servidor MariaDB dentro do container CentOS, agora você tem um container executando uma imagem, mas o container é diferente da imagem que você usou para criá-lo.

      Para salvar o estado do container como uma nova imagem, primeiro saia dele:

      • exit

      Em seguida, confirme ou faça o commit das alterações em uma nova instância de imagem Docker usando o seguinte comando. A chave -m é para a mensagem de commit que ajuda você e outras pessoas a saber quais alterações você fez, enquanto -a é usado para especificar o autor. O ID do container é aquele que você anotou anteriormente no tutorial quando iniciou a sessão Docker interativa. A menos que você tenha criado repositórios adicionais no Docker Hub, o repositório geralmente é seu nome de usuário do Docker Hub:

      • docker commit -m "O que você fez na imagem" -a "Nome do autor" container-id repositório/novo_nome_da_imagem

      Por exemplo:

      • docker commit -m "adicionado mariadb-server" -a "Sunday Ogwu-Chinuwa" 59839a1b7de2 finid/centos-mariadb

      Nota: Quando você faz o commit de uma imagem, a nova imagem é salva localmente, isto é, no seu computador. Posteriormente neste tutorial, você aprenderá a enviar uma imagem para um registro Docker, como o Docker Hub, para que ela possa ser avaliada e usada por você e por outras pessoas.

      Depois que a operação for concluída, listar as imagens Docker agora no seu computador deve mostrar a nova imagem, bem como a antiga da qual ela foi derivada:

      • docker images

      A saída deve ser desse tipo:

      Output
      REPOSITORY TAG IMAGE ID CREATED SIZE finid/centos-mariadb latest 23390430ec73 6 seconds ago 424.6 MB centos latest 778a53015523 5 weeks ago 196.7 MB hello-world latest 94df4f0ce8a4 2 weeks ago 967 B

      No exemplo acima, centos-mariadb é a nova imagem, que foi derivada da imagem CentOS existente do Docker Hub. A diferença de tamanho reflete as alterações que foram feitas. E neste exemplo, a mudança foi que o servidor MariaDB foi instalado. Então, da próxima vez que você precisar executar um container usando o CentOS com o servidor MariaDB pré-instalado, basta usar a nova imagem. As imagens também podem ser construídas a partir do que é chamado de Dockerfile. Mas esse é um processo mais complicado e que está bem fora do escopo deste artigo. Vamos explorar isso em um artigo futuro.

      Passo 7 — Listando os Containers Docker

      Depois de usar o Docker por um tempo, você terá muitos containers ativos (em execução) e inativos no seu computador. Para ver os ativos, use:

      • docker ps

      Você verá uma saída semelhante à seguinte:

      Output
      CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES f7c79cc556dd centos "/bin/bash" 3 hours ago Up 3 hours silly_spence

      Para visualizar todos os containers — ativos e inativos, passe a ele a chave -a:

      • docker ps -a

      Para ver o container mais recente que você criou, utilize a opção -l:

      • docker ps -l

      Parar um container em execução ou ativo é tão simples quanto digitar:

      • docker stop container-id

      O container-id pode ser encontrado na saída do comando docker ps.

      Passo 8 — Enviando Imagens para um Repositório Docker

      A próximo passo lógico depois de criar uma nova imagem a partir de uma imagem existente é compartilhá-la com alguns de seus amigos selecionados, o mundo inteiro no Docker Hub ou outro registro Docker ao qual você tem acesso. Para enviar uma imagem para o Docker Hub ou qualquer outro registro Docker, você deve ter uma conta lá.

      Esta seção mostra como enviar uma imagem para o Docker Hub.

      Para criar uma conta no Docker Hub, registre-se em Docker Hub. Depois, para enviar sua imagem, primeiro faça o login no Docker Hub. Você será solicitado a se autenticar:

      • docker login -u usuário_do_registro_docker

      Se você especificou a senha correta, a autenticação deve ser bem-sucedida. Então você pode enviar sua própria imagem usando:

      • docker push usuário_do_registro_docker/nome-da-imagem-docker

      Isso levará algum tempo para ser concluído e, quando concluído, a saída será algo assim:

      Output
      The push refers to a repository [docker.io/finid/centos-mariadb] 670194edfaf5: Pushed 5f70bf18a086: Mounted from library/centos 6a6c96337be1: Mounted from library/centos …

      Depois de enviar uma imagem para um registro, ela deve estar listada no painel da sua conta, como mostra a imagem abaixo.

      Docker image listing on Docker Hub

      Se uma tentativa de envio resultar em um erro desse tipo, provavelmente você não efetuou login:

      Output
      The push refers to a repository [docker.io/finid/centos-mariadb] e3fbbfb44187: Preparing 5f70bf18a086: Preparing a3b5c80a4eba: Preparing 7f18b442972b: Preparing 3ce512daaf78: Preparing 7aae4540b42d: Waiting unauthorized: authentication required

      Faça o login e repita a tentativa de envio.

      Conclusão

      Há muito mais no Docker do que foi mostrado neste artigo, mas isso deve ser suficiente para você começar a trabalhar com ele no CentOS 7. Como a maioria dos projetos open source, o Docker é construído a partir de uma base de código em rápido desenvolvimento, portanto, crie o hábito de visitar a página do blog do projeto para as informações mais recentes.

      Confira também os outros tutoriais do Docker na Comunidade da DigitalOcean.



      Source link

      Etapas Adicionais Recomendadas para Novos Servidores CentOS 7


      Introdução

      Depois de definir a configuração mínima para um novo servidor, existem algumas etapas adicionais que são altamente recomendadas na maioria dos casos. Neste guia, continuaremos a configuração de nossos servidores, abordando alguns procedimentos recomendados, mas opcionais.

      Pré-requisitos e Objetivos

      Antes de iniciar este guia, você deve passar pelo guia de Configuração Inicial do Servidor com o CentOS 7. Isso é necessário para configurar suas contas de usuário, configurar a elevação de privilégios com o sudo e bloquear o SSH por segurança.

      Depois de concluir o guia acima, você pode continuar com este artigo. Neste guia, nos concentraremos na configuração de alguns componentes opcionais, mas recomendados. Isso envolverá a configuração do nosso sistema com um firewall e um arquivo de swap, e configurar a sincronização do Network Time Protocol.

      Configurando um Firewall Básico

      Os firewalls fornecem um nível básico de segurança para o seu servidor. Esses aplicativos são responsáveis por negar tráfego a todas as portas do servidor com exceções das portas/serviços que você aprovou. O CentOS vem com um firewall chamado firewalld. Uma ferramenta chamada firewall-cmd pode ser usada para configurar suas políticas de firewall. Nossa estratégia básica será bloquear tudo o que não tivermos uma boa razão para manter em aberto. Primeiro instale o firewalld:

      • sudo yum install firewalld

      O serviço firewalld tem a capacidade de fazer modificações sem perder as conexões atuais, assim podemos ativá-lo antes de criar nossas exceções:

      • sudo systemctl start firewalld

      Agora que o serviço está funcionando, podemos usar o utilitário firewall-cmd para obter e definir informações de política para o firewall. O aplicativo firewalld usa o conceito de “zonas” para rotular a confiabilidade dos outros hosts em uma rede. Essa rotulagem nos dá a capacidade de atribuir regras diferentes, dependendo de quanto confiamos em uma rede.

      Neste guia, estaremos ajustando somente as políticas para a zona padrão ou default. Quando recarregarmos nosso firewall, essa será a zona aplicada às nossas interfaces. Devemos começar adicionando exceções ao nosso firewall para serviços aprovados. O mais essencial deles é o SSH, já que precisamos manter o acesso administrativo remoto ao servidor.

      Se você não modificou a porta em que o daemon SSH está sendo executado, é possível ativar o serviço pelo nome digitando:

      • sudo firewall-cmd --permanent --add-service=ssh

      Se você alterou a porta SSH do seu servidor, você terá que especificar a nova porta explicitamente. Você também precisará incluir o protocolo que o serviço utiliza. Somente digite o seguinte caso seu servidor SSH já tenha sido reiniciado para usar a nova porta:

      • sudo firewall-cmd --permanent --remove-service=ssh
      • sudo firewall-cmd --permanent --add-port=4444/tcp

      Isso é o mínimo necessário para manter o acesso administrativo ao servidor. Se você planeja executar serviços adicionais, também precisa abrir o firewall para esses serviços.

      Se você planeja executar um servidor web HTTP convencional, você precisará habilitar o serviço http:

      • sudo firewall-cmd --permanent --add-service=http

      Se você planeja executar um servidor web com SSL/TLS ativado, você também deve permitir o tráfego de https:

      • sudo firewall-cmd --permanent --add-service=https

      Se você precisar que o email SMTP esteja ativado, você pode digitar:

      • sudo firewall-cmd --permanent --add-service=smtp

      Para ver quaisquer serviços adicionais que você possa ativar por nome, digite:

      • sudo firewall-cmd --get-services

      Quando terminar, você poderá ver a lista das exceções que serão implementadas digitando:

      • sudo firewall-cmd --permanent --list-all

      Quando você estiver pronto para implementar as mudanças, recarregue o firewall:

      • sudo firewall-cmd --reload

      Se, após o teste, tudo funcionar conforme o esperado, você deverá certificar-se de que o firewall será iniciado na inicialização:

      • sudo systemctl enable firewalld

      Lembre-se de que você terá que abrir explicitamente o firewall (com serviços ou portas) para quaisquer serviços adicionais que você venha a configurar posteriormente.

      Configurar Fuso Horário e Sincronização do Network Time Protocol

      O próximo passo é ajustar as configurações de localização do seu servidor e configurar a sincronização do Network Time Protocol (NTP).

      O primeiro passo garantirá que seu servidor esteja operando no fuso horário correto. O segundo passo configurará seu servidor para sincronizar o relógio do sistema com o horário padrão mantido por uma rede global de servidores NTP. Isso ajudará a evitar algum comportamento inconsistente que pode surgir com relógios fora de sincronia.

      Configurar Fusos Horários

      Nosso primeiro passo é definir o fuso horário do nosso servidor. Este é um procedimento muito simples que pode ser realizado usando o comando timedatectl:

      Primeiro, dê uma olhada nos fusos horários disponíveis digitando:

      • sudo timedatectl list-timezones

      Isto lhe dará uma lista dos fusos horários disponíveis para o seu servidor. Quando você encontrar a configuração de região/fuso horário que estiver correta para o seu servidor, defina-a digitando:

      • sudo timedatectl set-timezone região/fuso_horário

      Por exemplo, para configurá-lo para o horário do leste dos Estados Unidos, você pode digitar:

      • sudo timedatectl set-timezone America/New_York

      Seu sistema será atualizado para usar o fuso horário selecionado. Você pode confirmar isso digitando:

      Configurar a Sincronização NTP

      Agora que você tem o seu fuso horário definido, devemos configurar o NTP. Isso permitirá que seu computador fique em sincronia com outros servidores, levando a uma maior previsibilidade nas operações que dependem da hora correta.

      Para a sincronização NTP, usaremos um serviço chamado ntp, que podemos instalar a partir dos repositórios padrão do CentOS:

      Em seguida, você precisa iniciar o serviço para esta sessão. Também habilitaremos o serviço para que ele seja iniciado automaticamente sempre que o servidor for inicializado:

      • sudo systemctl start ntpd
      • sudo systemctl enable ntpd

      Seu servidor agora corrigirá automaticamente o relógio do sistema para se alinhar aos servidores globais.

      Criar um Arquivo de Swap

      Adicionar "swap" a um servidor Linux permite que o sistema mova as informações acessadas por um programa em execução com menos frequência da RAM para um local no disco. Acessar os dados armazenados no disco é muito mais lento do que acessar a RAM, mas ter o swap disponível pode ser a diferença entre o aplicativo permanecer ativo e a falha. Isso é especialmente útil se você planeja hospedar bancos de dados em seu sistema.

      Conselhos sobre o melhor tamanho para um espaço de swap variam significativamente dependendo da fonte consultada. Geralmente, um valor igual ou o dobro da quantidade de RAM do seu sistema é um bom ponto de partida.

      Aloque o espaço que você deseja usar para o seu arquivo de swap usando o utilitário fallocate. Por exemplo, se precisarmos de um arquivo de 4 Gigabytes, podemos criar um arquivo de swap localizado em /swapfile digitando:

      • sudo fallocate -l 4G /swapfile

      Depois de criar o arquivo, precisamos restringir o acesso a ele para que outros usuários ou processos não consigam ver o que é gravado lá:

      Agora temos um arquivo com as permissões corretas. Para dizer ao nosso sistema para formatar o arquivo para swap, podemos digitar:

      Agora, diga ao sistema que ele pode usar o arquivo de swap digitando:

      Nosso sistema está usando o arquivo de swap para esta sessão, mas precisamos modificar um arquivo de sistema para que nosso servidor faça isso automaticamente na inicialização. Você pode fazer isso digitando:

      • sudo sh -c 'echo "/swapfile none swap sw 0 0" >> /etc/fstab'

      Com essa adição, seu sistema deve usar seu arquivo de swap automaticamente a cada inicialização.

      Para Onde Ir a partir Daqui?

      Agora você tem uma configuração inicial muito decente para o seu servidor Linux. A partir daqui, existem alguns lugares que você pode ir. Primeiro, você pode querer tirar um instantâneo ou snapshot do seu servidor em sua configuração atual.

      Tirando um Snapshot da sua Configuração atual

      Se você está satisfeito com sua configuração e deseja usar isso como uma base para futuras instalações, você pode tirar um snapshot do seu servidor através do painel de controle da DigitalOcean. A partir de outubro de 2016, os snapshots custam $0.05 por gigabyte por mês, com base na quantidade de espaço utilizado no sistema de arquivos.

      Para fazer isso, desligue seu servidor pela linha de comando. Embora seja possível fazer um snapshot de um sistema em execução, o desligamento garante que os arquivos no disco estejam todos em um estado consistente:

      Agora, no painel de controle da DigitalOcean, você pode tirar um snapshot visitando a guia "Snapshots" do seu servidor:

      DigitalOcean snapshot

      Depois de tirar seu snapshot, você poderá usar essa imagem como base para instalações futuras, selecionando o snapshot a partir da guia "My Snapshots" para imagens durante o processo de criação:

      DigitalOcean use snapshot

      Recursos Adicionais e Próximos Passos

      A partir daqui, o seu caminho depende inteiramente do que você deseja fazer com o seu servidor. A lista de guias abaixo não é de forma alguma exaustiva, mas representa algumas das configurações mais comuns que os usuários recorrem:

      Conclusão

      Nesse ponto, você deve saber como configurar uma base sólida para seus novos servidores. Espero que você também tenha uma boa ideia para os próximos passos. Sinta-se à vontade para explorar o site para mais ideias que você pode implementar em seu servidor.



      Source link