---
# System prepended metadata

title: XCP-ng 8.0 + Debian10 + Docker

---

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)

