Como criar uma pilha de lâmpadas à base de docker usando o Docker-Comppose no Ubuntu 18.04 Bionic Beaver Linux

Objetivo

Após este tutorial, você poderá criar um ambiente de lâmpada usando a tecnologia Docker.

Requisitos

• Permissões de raiz
• Conhecimento básico do Docker

Convenções

• # - requer que os comandos Linux sejam executados com privilégios de raiz também
  diretamente como usuário root ou por uso de sudo comando
• $ - Requer que os comandos do Linux sejam executados como um usuário não privilegiado regular

Outras versões deste tutorial

Ubuntu 20.04 (fossa focal)

Introdução

Docker é um projeto de código aberto destinado a fornecer software dentro containers. Você pode pensar em um contêiner como uma espécie de "pacote", um ambiente isolado que compartilha o kernel com a máquina host e contém tudo o que o aplicativo precisa. Todos os recipientes são construídos usando imagens (O repositório de imagens centrais para que elas sejam DockerHub).

Neste tutorial, veremos como criar uma pilha de lâmpadas baseada em componentes do dockerized: Após o “serviço por contêiner por contêiner”, reuniremos o ambiente usando Docker-Compose, uma ferramenta para orquestrar composições de contêineres.

Um serviço vs múltiplo para contêiner

Existem várias vantagens no uso de um serviço por contêiner, em vez de executar vários serviços no mesmo. Modularidade, por exemplo, (podemos reutilizar um contêiner para fins diferentes) ou uma melhor manutenção: é mais fácil se concentrar em uma peça específica de um ambiente em vez de considerar todos eles de uma vez. Se queremos respeitar essa filosofia, devemos criar um contêiner para cada componente da nossa pilha de lâmpadas: uma para apache-php e outra para o banco de dados. Os diferentes contêineres devem ser capazes de falar um com o outro: para orquestrar facilmente recipientes vinculados, usaremos Docker-Compose.

Etapas preliminares

Antes de prosseguir, precisamos instalar Docker e Docker-Compose em nosso sistema:

# APT-Get Install Docker Docker-Compose

Os pacotes serão instalados em alguns segundos e o Docker O serviço será iniciado automaticamente. Agora podemos prosseguir para criar um diretório para o nosso projeto e dentro dele, outro para segurar as páginas que serão servidas pelo Apache. Documentroot seria um nome significativo para ele; Nesse caso, a única página que será servida índice.php:

$ mkdir -p Dockerized-lamp/documentroot $ echo ""> dockerized-lamp/documentroot/index.php 

Aqui nosso código consiste simplesmente no phpinfo Função: é saída (uma página mostrando informações sobre PHP, caso você não saiba) será o que nosso servidor será exibido por padrão. Agora vamos usar nosso editor favorito para criar o Docker-Compose.yml Arquive o nosso projeto.

Php-apache

Agora podemos começar a fornecer instruções sobre a criação e conexão de nossos contêineres no arquivo Docker-Compose. Este é um arquivo que usa o Yaml sintaxe. Todas as definições devem ser fornecidas no Serviços seção.

Versão: '3' Serviços: PHP-APACHE: Imagem: PHP: 7.2.1 - portas de apache: - 80:80 Volumes: - ./Documentroot:/var/www/html links: - 'mariadb' 

Vamos dar uma olhada no que acabamos de fazer aqui. A primeira linha que inserimos no arquivo, versão, Especifica qual versão da sintaxe do Docker-Compose 3, A última versão principal disponível. Dentro de Serviços Seção, começamos a descrever nosso serviço especificando seu nome, php-apache (um nome arbitrário, você pode usar o que quiser), então as instruções para construí -lo.

O imagem A palavra -chave permite que o Docker saiba qual imagem queremos usar para construir nosso contêiner: neste caso, usei 7.2.1-Apache que nos fornecerá Php 7.2.1 junto com o servidor da web do Apache. Precisa de outra versão PHP? Você só precisa escolher entre os muitos fornecidos na página da imagem no DockerHub.

A segunda instrução que fornecemos é portas: Estamos dizendo ao Docker para mapear a porta 80 Em nosso anfitrião, para o porto 80 No contêiner: desta maneira aparecerá quando estávamos executando o servidor da web diretamente em nosso sistema.

Nós então usamos o volumes instrução para especificar um montagem em ligação. Como durante o desenvolvimento o código muda muito e rápido, não haveria sentido em colocar o código diretamente dentro de um contêiner: dessa forma, devemos reconstruí -lo toda vez que fazemos algumas modificações. Em vez disso, o que vamos fazer é dizer ao Docker para ligar o Documentroot diretório, em /var/www/html dentro do recipiente. Este diretório representa o Apache principal VirtualHost Raiz do documento, portanto, o código que colocamos dentro dele estará disponível imediatamente.

Finalmente usamos o link palavra -chave especificando Mariadb como seu argumento. Essa palavra -chave não é necessária, como pode parecer, para criar uma conexão entre os dois recipientes: mesmo sem especificá -lo, o Mariadb o serviço seria acessível de dentro do recipiente construído para o apache-php Serviço, usando seu nome como um nome de host. A palavra -chave faz duas coisas: primeiro vamos especificar opcionalmente Alias Podemos usar para fazer referência a um serviço, além de seu nome. Então, por exemplo, escrevendo:

Link: Mariadb: serviço de banco de dados 

O serviço também pode ser alcançado usando Database-Service. A segunda coisa link é especificar uma dependência: neste caso o php-apache o serviço será considerado dependente do Mariadb um, então o último será iniciado antes do primeiro ao construir ou iniciar o meio ambiente.

Instale extensões PHP

O Dockerfile Php-Apache padrão não inclui algumas extensões de PHP, como MySQLI ou PDO. Para instalá -los, temos que construir nosso próprio Dockerfile, com base nele. Para fazer isso, criamos um diretório dentro do nosso projeto chamado php-apache (este será o nosso construir contexto) e dentro dele, nosso Dockerfile. Cole e salve o código abaixo como Php-Apache/Dockerfile:

 De Php: 7.2.Manter 1-Apache Egidio Docile Run Docker-Php-EXT-INSTALL PDO PDO_MYSQL MYSQLI 

Como você pode ver, com o DE Instrução, especificamos que este Dockerfile deve ser baseado no padrão. Então nós incluímos um CORRER Instrução: Usando o script fornecido na própria imagem, Docker-Php-Ext-Install, Incluímos as extensões necessárias para usar PDO e Mysqli. Neste ponto, se queremos usar nosso Dockerfile personalizado, precisamos alterar levemente a seção Php-Apache em nosso Docker-Compose.YML, desta forma:

Versão: '3' Serviços: Php-apache: Build: Contexto: ./PHP -APACHACHETS: - 80:80 Volumes: - ./Documentroot:/var/www/html links: - 'mariadb' 

O que mudou? Em vez de especificar diretamente a imagem remota a ser usada, fornecemos o contexto instrução, dentro do construir Seção, para que o Dockerfile contido no diretório que criamos e aqui fornecido como argumento, será usado automaticamente. O diretório de contexto é importado pelo Docker Daemon ao criar a imagem; portanto, se quisermos adicionar arquivos adicionais, precisamos colocá -los também lá.

O serviço de banco de dados

Um banco de dados em uma parte essencial de um ambiente de lâmpada, é usado para persistência. Nesse caso, vamos usar Mariadb:

Mariadb: Imagem: Mariadb: 10.1 Volumes: - MARIADB:/var/lib/mysql Ambiente: TZ: "Europa/Roma" mysql_allow_empty_password: "não" mysql_root_password: "rootpwd" mysql_user: 'testUser' mysql_password: 'testwd' mysql_user: 'testuser' 'mysql_password:' testwd 'mysql_user:' 

Já sabemos o que o imagem palavra -chave é para. O mesmo vale para o volumes instrução, exceto pelo fato de que desta vez não declaramos um montagem em ligação, Em vez disso, referenciamos um Volume nomeado, para persistência. É importante se concentrar na diferença entre os dois por um momento.

Como dito antes, um montagem em ligação é uma maneira rápida de montar um diretório host dentro de um recipiente, para que os arquivos contidos no referido diretório se tornem acessíveis a partir do ambiente restrito: especificar um suporte de ligação, o Sintaxe curta é:

:

O caminho do host pode ser um parente (ao arquivo do docker-compor) ou um caminho absoluto, enquanto o MountPoint dentro do recipiente deve ser especificado em forma absoluta.

A Volume nomeado é algo diferente: é adequado Volume do docker Usado para persistência, e geralmente deve ser preferido sobre um suporte de ligação, porque não depende da estrutura do arquivo host (uma das muitas vantagens dos contêineres é a portabilidade deles). A sintaxe a ser usada para referir um Volume nomeado Dentro de uma definição de serviço está:

:

A Volume nomeado O ciclo de vida é independente do de um recipiente que o usa e deve ser declarado no volumes Seção do arquivo Docker-Comppose, como veremos em um momento.

De volta à definição do serviço agora. A última palavra -chave que usamos é ambiente: permite definir algumas variáveis ​​de ambiente que influenciarão o comportamento do serviço. Primeiro usamos Tz Para especificar nosso fuso horário do banco de dados: neste caso, usei "Europa/Roma". Os nomes das outras variáveis ​​dizem tudo sobre o seu propósito: usando -os, definimos detalhes importantes como o nome do banco de dados padrão a ser criado (TestDB), o usuário a ser criado e sua senha. Também definimos a senha do usuário root e decidimos não permitir senhas vazias.

A seção de volumes

Nesta seção, devemos declarar o Volume nomeado nós referenciamos do Mariadb Definição do servidor:

Volumes: mariadb: 

No final, é assim que nosso arquivo ficará na íntegra:

Versão: '3' Serviços: PHP-APACHE: Imagem: PHP: 7.2.1 - portas de apache: - 80:80 Volumes: - ./Documentroot:/var/www/html: z links: - 'mariadb' mariadb: imagem: mariadb: 10.1 Volumes: - MARIADB:/var/lib/mysql Ambiente: TZ: "Europa/Roma" mysql_allow_empty_password: "não" mysql_root_password: "rootpwd" mysql_user: 'testUser' mysql_password: 'test' 'mysql_user:' testuser 'myaSql_password:' Test '' 'Mysql_User:' TestUser '' MyAmArpWord: 'Test' '' 

É realmente importante respeitar o recuo para o arquivo ser interpretado corretamente.

Vamos construir nosso ambiente

Depois de especificarmos todas as instruções para nossos serviços, podemos usar o Docker-compor comando para construí -los. O comando deve ser executado dentro do mesmo diretório em que o Docker-Compose.yml O arquivo está localizado:

# Docker-Compor Up

Poucos minutos e estaremos prontos para ir. No final, se tudo correu bem, navegando para LocalHost Em nosso host, veremos a saída do script PHP que colocamos dentro Documentroot:

Nosso ambiente de lâmpada agora está pronto para ser usado.

Pensamentos finais

Vimos como criar um básico LÂMPADA ambiente, usando o docker e os contêineres e serviços de orquestra Docker-Compose. A configuração que usamos está focada no desenvolvimento e pode ser expandida e aprimorada para atender às necessidades diferentes: documentação do Docker É uma fonte muito bem escrita que você pode consultar para expandir seu conhecimento do Docker. Não hesite em deixar um comentário sobre quaisquer dúvidas ou perguntas que você tenha.

Tutoriais do Linux relacionados:

• Coisas para instalar no Ubuntu 20.04
• Coisas para fazer depois de instalar o Ubuntu 20.04 fossa focal linux
• Como criar uma pilha de lâmpadas à base de docker usando o docker em…
• Ubuntu 20.04 truques e coisas que você pode não saber
• Ubuntu 20.04 Guia
• Ubuntu 20.04 Hadoop
• Os 8 melhores ambientes de desktop do Ubuntu (20.04 Fossa focal…
• Lista de clientes FTP e instalação no Ubuntu 20.04 Linux…
• Como se conectar ao contêiner do Docker via SSH
• Como instalar a pilha de lâmpadas no Almalinux