XCP-ng 8.0 + Debian10 + Docker
===
Para efeitos de didática considerarei a VM Debian10 já instalada e com rede configurada em um servidor XCP-ng 8.0, tendo em vista que são procedimento bastante normais e com vasto material disponível.
Instalação do Docker
==
**Logue-se como root na VM Debian 10**
Proxy
=
Caso seu servidor esteja atrás de um proxy será necessário configurá-lo, do contrário, ignore esta etapa e vá direto para os Pacotes necessários
```javascript
vim /etc/apt/apt.conf
```
Insira as linhas
```javascript
Acquire::http::Proxy "http://<ip-do-proxy>:<porta>/";
Acquire::https::Proxy "http://<ip-do-proxy>:<porta>/";
```
Exporte o proxy no sistema com os comandos
```javascript
export http_proxy=http://<ip-do-proxy>:<porta>/
```
```javascript
export https_proxy=http://<ip-do-proxy>:<porta>/
```
Para que o docker consiga baixar as imagens configure as entradas de proxy da seguinte maneira
Crie o diretório
```javascript
mkdir /etc/systemd/system/docker.service.d
```
Crie o seguinte arquivo
```javascript
vim /etc/systemd/system/docker.service.d/http-proxy.conf
```
Adicione o seguinte conteúdo
```javascript
[Service]
Environment="HTTP_PROXY=http://<ip-do-proxy>:<porta>/"
Environment="HTTPS_PROXY=http://<ip-do-proxy>:<porta>/"
```
Se quiser que o docker não utilize proxy para determinado endereço interno acrescente uma linha com os endereços como no exemplo abaixo
```javascript
Environment="NO_PROXY=localhost,127.0.0.0/8,docker-registry.somecorporation.com, endereço-que-vcquiser"
```
Reinicie o daemon para validar:
```javascript
sudo systemctl daemon-reload
```
Verifique se a configuração foi carregada:
```javascript
sudo systemctl show --property Environment docker
```
A saída esperada é algo como
```javascript
Environment=HTTP_PROXY=http://<ip-do-proxy>:<porta>/ HTTPS_PROXY=http://<ip-do-proxy>:<porta>/
```
Pacotes necessários
=
Atualizando e instalando os pacotes e dependências no Debian 10
```javascript
apt-get update && apt-get upgrade -y && apt-get install curl openssh-server nmap ncat sudo -y
```
Instalando o Docker
=
Instale o docker com o comando
```javascript
curl -fsSl https://get.docker.com/ | sh
```
Habilite o usuario comum do seu sistema para o grupo do docker, neste exemplo, o usuário **info** criado na instalação do Debian10 (utilize o sudo mesmo como root)
```javascript
sudo usermod -aG docker info
```
Testando o docker
=
Para verificar se o docker está rodando na vm execute
```javascript
docker --version
```
Será exibido algo como
```javascript
Docker version 19.03.2, build 6a30dfc
```
**Não nos aprofundaremos no tema docker por não ser o foco deste tutorial.**
Gerenciando pelo XCP-ng
==
Instalando o xen guest tootls (VMs Linux)
=
Pelo XOCE/XOA
```javascript
Home > VMs > Clicar no nome da VM > Aba Disks > No final da página aparecerá um menu tipo Drop Down (Select disks...), selecione "guest-tools.iso - XCP-ng Tools " para inserir a imagem no drive de CD da VM.
```
Pelo XCP-ng Center
```javascript
Selecionar a VM > Menu VM > Instalar XCP-ng Tootls
```
Estes processos acima correspondem a inserir um CD/DVD com as ferramentas na VM
No console da VM, monte e execute o script,
Vamos também exportar temporariamente o PATH /usr/sbin (PARA DEBIAN10)
```javascript
export PATH=$PATH:/usr/sbin
```
```javascript
mount /dev/cdrom /mnt
```
```javascript
bash /mnt/Linux/install.sh
```
```javascript
reboot (ou systemctl reboot)
```
Se tudo correu bem, na listagem de VMs do XOA/XOCE, na frente do nome da VM aparecerá o símbolo do Debian
PS: Após o reboot, não se esqueça de ejetar a imagem guest-tools.iso do drive de CD da VM
Via XCP-ng
```javascript
xe vm-cd-eject vm=NOME_DA_VM
```
Instalando o xscontainer no XEN
=
No console do XCP-ng, instale o xscontainer
```javascript
yum update -y
```
```javascript
yum install xscontainer
```
liste as vms pra pegar o uuid da vm docker
```javascript
xe vm-list
```
Copie o uuid da vm
Habilitando a VM docker no XEN
=
Habilitei a vm docker para gerenciamento de containers
```javascript
xscontainer-prepare-vm -v dae033fe-80fb-c4f5-f198-be2a603756b2 -u info
```
Consirede que para o comanda acima:
- dae033fe-80fb-c4f5-f198-be2a603756b2: UUID da VM
- info: Usuário da VM docker que habilitamos acima:
Responda yes em todas as perguntas para importar as chaves ssl e insira a senha do usuário info quando solicitado
Finalizando
=
Para validar a instalação e integração você **deve reiniciar** o seu servidor (host) XCP-ng, **se este servidor estiver em um pool comece reiniciando o MASTER e depois os outros hosts do pool**
Será abilitado no XCP-ng center, na aba geral da vm as informações do docker, e nas propriedades da vm será habilitado o container management.
No XOA/XOCE, na visualização da VM, será habilitada a aba Container
Os containers criados ficarão aninhados abaixo da vm docker.
Testando o docker
==
Vamos criar um ambiente LAMP dentro da VM docker para validar a instalação, **obviamente esta VM deve ter acesso à internet para baixar as imagens dos containers**
Docker-compose
=
O docker-compose é uma forma de se orquestrar seu ambiente, sendo isso possível utilizando um único arquivo yml para gerenciar vários componentes da sua solução.
Com ele é possível criar e gerenciar vários containers em um único arquivo facilitando a escabilidade da aplicação.
Resumidamente, ele "orquestra" seus containers
Instalando o docker-compose
=
Acesse **como root** a VM docker e baixe o docker-compose, aqui a versão 1.24.1 (altere a URL se quiser outra versão)
```javascript
curl -L https://github.com/docker/compose/releases/download/1.24.1/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
```
Ajuste as permissões
```javascript
chmod +x /usr/local/bin/docker-compose
```
Verifique se foi instalado corretamente
```javascript
docker-compose --version
```
Uma saída como esta deve ser exibida
```javascript
docker-compose version 1.24.1, build 4667896b
```
Crie um diretório para o exemplo e acesse-o
```javascript
mkdir /home/lamp && cd /home/lamp
```
Crie um diretório para armazernar o Dockerfile de criação do PHP
```javascript
mkdir /home/lamp/php
```
Crie um diretório para usarmos como volume compartilhado entre o host e o container, nele guardaremos os arquivos php
```javascript
mkdir /home/lamp/php/www
```
Crie também um diretório compartilhado para ser usado como volume de armazenamento dos arquivos do mysql
```javascript
mkdir /home/lamp/mysql
```
Crie um arquivo yml
```javascript
vim /home/lamp/docker-compose.yml
```
Utilize o seguinte conteúdo
**IMPORTANTÍSSIMO:** Respeite a concatenação deste arquivo, o aninhamento de cada linha é interpretado pelo docker-compose, portanto sugiro que, caso dê algum erro, digite manualmente linha por linha pois alguma quebra de linha ou caracter pode ter sido inserido durante o Crtl+c Ctrl+v. Altere **as senhas** e o nome do banco no arquivo para uma de seu conhecimento
```javascript=
php:
build: ./php
ports:
- "80:80"
- "443:443"
volumes:
- "/home/lamp/php/www:/var/www/html"
links:
- mysql
environment:
- MYSQL_USER=root
- MYSQL_PASS=senha123
mysql:
image: mysql:5.7
volumes:
- "./mysql:/var/lib/mysql"
ports:
- "3306:3306"
environment:
- MYSQL_ROOT_PASSWORD=senha123
- MYSQL_DATABASE=meubanco
phpmyadmin:
image: phpmyadmin/phpmyadmin:latest
links:
- mysql
ports:
- "8888:80"
environment:
- PMA_ARBITRARY=1
```
Traduzindo o arquivo yml
=
Neste arquivo estamos dizendo:
- Existem 3 seções neste projeto, 3 containers diferentes que irão interagir, o container chamado **php**, o container **mysql** e o container **phpmyadmin**
- o build (construtor) usará o arquivo Dockerfile dentro da pasta php local para construir o container php
- as portas 80 e 443 do host estarão direcionadas para as portas 80 e 443 do container php
- o diretório /home/lamp/php/www do host será montada como volume no diretório /var/www/html do container, portando compartilhada entre eles, qualquer arquivo ou diretório criado em um estará disponível para o outro, esta é uma forma de se colocar ou tirar arquivos de dentro de um container.
- o container php estará linkado, ou seja, conhece o container mysql
- foram passadas duas variáveis de ambiente php para conexão com o banco, que são o usuário e senha do root
- no container mysql será utilizada a versão 5.7 do banco
- a pasta mysql local será compartilhada como volume em /var/lib/mysql no container
- a porta 3306 do host será direcionada par a porta 3306 do container
- foram passadas as variaveis de ambiente PASSWORD e DATABASE para a criação do banco
- o container phpmyadmin usará a última versão disponível do programa (latest)
- o container phpmyadmin conhecerá o container mysql
- a porta **8888** do host será direcionada para a porta 80 do container phpmyadmin
- uma variável que informa ao PHPMyAdmin para exibir o endereço de conexão do seu servidor caso você queira conectar em vários servidores do MySQL a partir de uma única instalação do PHPMyAdmin.
Criando o arquivo Dockerfile
=
O Dockerfile é o arquivo responsavel pela criação do container, nele serão inseridas as informações que serão utilizadas durante a instalação de pacotes dentre outras, já que não é possível iteragir com o container durante sua criação. Por exemplo, durante a instalação do php normalmente são solicitadas algumas informações e ou confirmações, no caso do docker isso é passado ao instalador pelo Dockerfile
Importante: Tanto o Dockerfile quanto o docker-compose.yml devem manter **EXATAMENTE este nome**, **Dockerfile** com D maiúsculo e **docker-compose.yml** tudo minusculo.
Crie o arquivo Dockerfile
=
```javascript
vim /home/lamp/php/Dockerfile
```
Conteúdo: As mesmar orientações valem para o Ctrl+c e o Ctrl+v deste conteúdo
```javascript=
FROM php:7.2-apache
RUN apt-get update
RUN apt-get install -y apt-utils vim curl
RUN docker-php-ext-install mysqli pdo_mysql
RUN a2enmod rewrite
```
Traduzindo o arquivo Dockerfile
=
- Será utilizada a versão 7.2 do php com apache
- Executará uma série de comandos de instalação de pacutes
- Instalará algumas dependências necessárias
- Habilitará o módulo rewrite do apache
Subindo os containers
=
Estando no diretório /home/lamp execute
```javascript
docker-compose -f "docker-compose.yml" up -d --build
```
O docker buscará no docker-hub as imagens indicadas no arquivo e subira automaticamente os containers
Descendo os containers (desligando)
```javascript
docker-compose -f "docker-compose.yml" down
```
Conclusão
=
- Acessando o ip do host na porta 80 você será direcionado para o site dentro do apache do container (www)
- Para colocar arquivos na pasta www do container basta colocá-los na pasta /home/lamp/php/www
- Acessando o ip do host na porta **8888** você será direcionado para o container phpmyadmin
- Para acessar o phpmyadmin, no campo servidor, coloque o nome do container que contém o banco de dados, no caso, **mysql**
- Utilize o usuário root e a senha informada no arquivo .yml
**Enjoy**
by @pedrosa2004
Grupo Telegram : [https://t.me/xcpng](https://t.me/xcpng)
Sign in with Wallet
Connect another wallet