Post

Infraestrutura de Estudos DCA Usando KVM, Terraform e Ansible

Este tutorial guia a implementação de uma infraestrutura DCA (Docker Container Architecture) utilizando KVM, Terraform e Ansible, com foco na automação do provisionamento de VMs e instalação de Docker.

Posted Updated
By Gean Martins
16 min read
Infraestrutura de Estudos DCA Usando KVM, Terraform e Ansible

Sumário

  1. Parte 1: Infraestrutura e Arquitetura
  2. Parte 2: Configuração do Cloud-init e Inicialização das VMs
  3. Parte 3: Redirecionamento de Porta para Acesso às VMs
  4. Parte 4: Instalação do Ansible e Configuração do Inventário
  5. Parte 5: Playbook para Instalar o Docker

Parte 1: Infraestrutura e Arquitetura

1.1 - Arquitetura e Serviços

A arquitetura será composta de serviços distintos que serão configurados em diferentes máquinas virtuais (VMs) e um host físico. Abaixo, está uma tabela que detalha as funções de cada componente:

Serviço/ComponenteHost (IP/Hostname)Função
Ansible e Terraform192.168.0.100Gerenciamento da infraestrutura e automação
KVM (Hypervisor)192.168.0.250Host de virtualização, onde as VMs serão provisionadas
dca-manager (VM)10.4.5.10Executa funções de orquestração e gerenciamento de cluster
dca-wk-01 (VM)10.4.5.11Nó de trabalho do cluster
dca-wk-02 (VM)10.4.5.12Nó de trabalho do cluster
dca-registry (VM)10.4.5.13Registro de imagens Docker

1.2 - Preparação do Ambiente KVM e Terraform

O ambiente de virtualização usará KVM para gerenciar as VMs e Terraform para provisionar a infraestrutura. As VMs serão configuradas no servidor KVM, com o Terraform atuando na automação.

Nota: Antes de continuar, certifique-se de que o KVM e o Terraform estão instalados no host físico (192.168.0.250). Para um guia de instalação, você pode acessar: guia de instalação.

1.3 - Provisionamento de VMs usando Terraform

Agora vamos criar os arquivos de configuração do Terraform para provisionar as VMs.

1.3.1 - Arquivo main.tf

O arquivo main.tf é responsável por definir a infraestrutura, incluindo a criação das VMs, discos e a rede virtual.

  1. Crie o arquivo main.tf:
    1

    vim main.tf
  2. Adicione o conteúdo abaixo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

terraform {
  required_providers {
    libvirt = {
      source = "dmacvicar/libvirt"
    }
  }
}

provider "libvirt" {
  # uri = "qemu:///system"
  uri = "qemu+ssh://gean@192.168.0.250/system"
}

variable "vms" {
  type = list(map(any))
}

# Definir a rede virtual 'ansible'
resource "libvirt_network" "dca" {
  name      = "dca"
  mode      = "nat"
  addresses = ["10.4.5.0/24"]
  autostart = true
  dhcp {
    enabled = false
  }
  dns {
    enabled = true
  }
}

# Criar volumes de sistema operacional
resource "libvirt_volume" "os_image" {
  for_each = { for vm in var.vms : vm.name => vm }

  name   = each.value.os_image_name
  pool   = each.value.storage_pool
  source = each.value.os_image_url
  format = "qcow2"
}

# Criar volumes de dados
resource "libvirt_volume" "vol_docker" {
  for_each = { for vm in var.vms : vm.name => vm }

  name = each.value.vol_docker_name
  pool = each.value.storage_pool
  size = each.value.disksize * 1024 * 1024 * 1024 // GB to bytes
}

# Arquivo de configuração de usuário para Debian/Ubuntu
data "template_file" "user_data_deb" {
  for_each = { for vm in var.vms : vm.name => vm if lookup(vm, "user_data_deb", null) != null }

  template = file("${path.module}/${each.value.user_data_deb}")
  vars = {
    hostname = each.value.hostname
  }
}

# Arquivo de configuração de usuário para RHEL
data "template_file" "user_data_rhel" {
  for_each = { for vm in var.vms : vm.name => vm if lookup(vm, "user_data_rhel", null) != null }

  template = file("${path.module}/${each.value.user_data_rhel}")
  vars = {
    hostname = each.value.hostname
  }
}

# Configuração de rede para Debian/Ubuntu
data "template_file" "network_config_deb" {
  for_each = { for vm in var.vms : vm.name => vm if lookup(vm, "network_config_deb", null) != null }

  template = file("${path.module}/${each.value.network_config_deb}")
  vars = {
    network_ip = each.value.network_ip
  }
}

# Configuração de rede para RHEL
data "template_file" "network_config_rhel" {
  for_each = { for vm in var.vms : vm.name => vm if lookup(vm, "network_config_rhel", null) != null }

  template = file("${path.module}/${each.value.network_config_rhel}")
  vars = {
    network_ip = each.value.network_ip
  }
}

# Criar discos cloud-init para as VMs Debian/Ubuntu
resource "libvirt_cloudinit_disk" "cloudinit_deb" {
  for_each = { for vm in var.vms : vm.name => vm if lookup(vm, "user_data_deb", null) != null }

  name           = "${each.key}_cloudinit.iso"
  user_data      = data.template_file.user_data_deb[each.key].rendered
  network_config = data.template_file.network_config_deb[each.key].rendered
  pool           = each.value.storage_pool
}

# Criar discos cloud-init para as VMs RHEL
resource "libvirt_cloudinit_disk" "cloudinit_rhel" {
  for_each = { for vm in var.vms : vm.name => vm if lookup(vm, "user_data_rhel", null) != null }

  name           = "${each.key}_cloudinit.iso"
  user_data      = data.template_file.user_data_rhel[each.key].rendered
  network_config = data.template_file.network_config_rhel[each.key].rendered
  pool           = each.value.storage_pool
}

# Definir cloudinit de acordo com o sistema operacional
locals {
  cloudinit_disks = {
    for vm in var.vms : vm.name => (
      lookup(vm, "user_data_deb", null) != null ?
      libvirt_cloudinit_disk.cloudinit_deb[vm.name].id :
      libvirt_cloudinit_disk.cloudinit_rhel[vm.name].id
    )
  }
}

# Criar as VMs
resource "libvirt_domain" "domain" {
  for_each = { for vm in var.vms : vm.name => vm }

  name   = each.value.name
  memory = each.value.memory
  vcpu   = each.value.cpu

  cpu {
    mode = "host-passthrough"
  }

  cloudinit = local.cloudinit_disks[each.key]

  network_interface {
    network_name = each.value.network_name
  }

  disk {
    volume_id = libvirt_volume.os_image[each.key].id
  }

  disk {
    volume_id = libvirt_volume.vol_docker[each.key].id
  }

  console {
    type        = "pty"
    target_type = "virtio"
    target_port = "1"
  }

  graphics {
    type        = "spice"
    listen_type = "address"
    autoport    = true
  }
}

Este arquivo cria as VMs especificadas nas variáveis e define o uso de cloud-init para configurar o sistema operacional.

1.3.2 - Definir as Variáveis (terraform.tfvars)

Crie um arquivo terraform.tfvars para definir as VMs e suas configurações:

1

vim terraform.tfvars

Adicione o seguinte conteúdo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

vms = [
  {
    name               = "dca-manager"
    cpu                = 2
    memory             = 4096
    disksize           = 32
    storage_pool       = "default"
    hostname           = "dca-manager"
    os_image_name      = "dca-manager-image.qcow2"
    vol_docker_name    = "dca-manager-docker.qcow2"
    network_name       = "dca"
    user_data_deb      = "cloud-init-deb.yml"
    network_config_deb = "network-config-deb.yml"
    network_ip         = "10.4.5.10"
    os_image_url       = "/home/gean/kvm/templates/ubuntu-22.04-server-cloudimg-amd64.img"
  },
  {
    name               = "dca-wk-01"
    cpu                = 2
    memory             = 2048
    disksize           = 32
    storage_pool       = "default"
    hostname           = "dca-wk-01"
    os_image_name      = "wk-01-image.qcow2"
    vol_docker_name    = "wk-01-docker.qcow2"
    network_name       = "dca"
    user_data_deb      = "cloud-init-deb.yml"
    network_config_deb = "network-config-deb.yml"
    network_ip         = "10.4.5.11"
    os_image_url       = "/home/gean/kvm/templates/ubuntu-22.04-server-cloudimg-amd64.img"
  },
  {
    name               = "dca-wk-02"
    cpu                = 2
    memory             = 2048
    disksize           = 32
    storage_pool       = "default"
    hostname           = "dca-wk-02"
    os_image_name      = "wk-02-image.qcow2"
    vol_docker_name    = "wk-02-docker.qcow2"
    network_name       = "dca"
    user_data_deb      = "cloud-init-deb.yml"
    network_config_deb = "network-config-deb.yml"
    network_ip         = "10.4.5.12"
    os_image_url       = "/home/gean/kvm/templates/ubuntu-22.04-server-cloudimg-amd64.img"
  },
  {
    name               = "dca-registry"
    cpu                = 2
    memory             = 2048
    disksize           = 32
    storage_pool       = "default"
    hostname           = "dca-registry"
    os_image_name      = "dca-registry-image.qcow2"
    vol_docker_name    = "dca-registry-docker.qcow2"
    network_name       = "dca"
    user_data_deb      = "cloud-init-deb.yml"
    network_config_deb = "network-config-deb.yml"
    network_ip         = "10.4.5.13"
    os_image_url       = "/home/gean/kvm/templates/ubuntu-22.04-server-cloudimg-amd64.img"
  }
]

Parte 2: Configuração do Cloud-init e Inicialização das VMs

Nesta parte, você configurará os arquivos cloud-init para definir as propriedades das VMs, como hostname, rede, pacotes de software e particionamento de disco. Esses arquivos serão aplicados automaticamente quando as VMs forem criadas com o Terraform.

2.1 - Arquivo cloud-init-deb.yml

Este arquivo define as configurações para as VMs baseadas em distribuições Debian/Ubuntu.

  1. Crie o arquivo cloud-init-deb.yml:
    1

    vim cloud-init-deb.yml
  2. Adicione o conteúdo abaixo:
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

    #cloud-config
ssh_pwauth: yes

users:
  - name: gean
    sudo: ALL=(ALL) NOPASSWD:ALL  
    groups: users, sudo
    shell: /bin/bash
    lock_passwd: false 
    passwd: $6$GzfiH4/buKEq8sVV$8J3wpTilvuDPDD2wlVIwxJ4AMU4Q.uq09PqB.vV3.y7Gdrcu.Xmg.T9/2U7ZlIA.7rco14IAsVrAIdkWUpOps. 

chpasswd:
  list: |
    root:root
  expire: False 

packages:
  - qemu-guest-agent
  - bash-completion

package_update: true
package_upgrade: true 

runcmd:
  - hostnamectl set-hostname ${hostname}
  - apt-get install -y lvm2 
  - pvcreate /dev/vdb
  - vgcreate docker_vg /dev/vdb
  - lvcreate -l 100%FREE -n docker_lv docker_vg
  - mkfs.ext4 /dev/docker_vg/docker_lv
  - mkdir -p /var/lib/docker
  - mount /dev/docker_vg/docker_lv /var/lib/docker
  - echo "/dev/docker_vg/docker_lv /var/lib/docker ext4 defaults 0 0" >> /etc/fstab

2.2 - Arquivo cloud-init-rhel.yml

Este arquivo será utilizado para VMs baseadas em distribuições RHEL/Oracle Linux.

  1. Crie o arquivo cloud-init-rhel.yml:
    1

    vim cloud-init-rhel.yml
  2. Adicione o seguinte conteúdo:
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

    #cloud-config
ssh_pwauth: yes

users:
  - name: gean
    sudo: ALL=(ALL) NOPASSWD:ALL  
    groups: users, wheel
    shell: /bin/bash
    lock_passwd: false  
    passwd: $6$GzfiH4/buKEq8sVV$8J3wpTilvuDPDD2wlVIwxJ4AMU4Q.uq09PqB.vV3.y7Gdrcu.Xmg.T9/2U7ZlIA.7rco14IAsVrAIdkWUpOps. 

chpasswd:
  list: |
    root:root
  expire: False  

packages:
  - qemu-guest-agent  
  - bash-completion  

package_update: true  
package_upgrade: true  

runcmd:
  - systemctl enable qemu-guest-agent
  - systemctl start qemu-guest-agent
  - hostnamectl set-hostname ${hostname}
  - pvcreate /dev/vdb
  - vgcreate docker_vg /dev/vdb
  - lvcreate -l 100%FREE -n docker_lv docker_vg
  - mkfs.xfs /dev/docker_vg/docker_lv
  - mkdir -p /var/lib/docker
  - mount /dev/docker_vg/docker_lv /var/lib/docker
  - echo "/dev/docker_vg/docker_lv /var/lib/docker xfs defaults 0 0" >> /etc/fstab

2.3 - Arquivo de Configuração de Rede para Debian/Ubuntu

  1. Crie o arquivo network-config-deb.yml:
    1

    vim network-config-deb.yml
  2. Adicione o seguinte conteúdo:
    1
2
3
4
5
6
7
8
9
10
11
12
13

    #cloud-config
network:
  version: 2
  ethernets:
    ens3:
      addresses:
        - ${network_ip}/24
      nameservers:
        addresses: 
          - 10.4.5.1
      routes:
        - to: default
          via: 10.4.5.1

2.4 - Arquivo de Configuração de Rede para RHEL/Oracle Linux

  1. Crie o arquivo network-config-rhel.yml:
    1

    vim network-config-rhel.yml
  2. Adicione o seguinte conteúdo:
    1
2
3
4
5
6
7
8
9
10
11

    #cloud-config
network:
  version: 1
  config:
    - type: physical
      name: eth0
      subnets:
        - type: static
          address: ${network_ip}/24
          gateway: 10.4.5.1
          dns_nameservers: 10.4.5.1

2.5 - Inicializando a Infraestrutura com Terraform

Com todos os arquivos configurados, agora você pode usar o Terraform para iniciar e provisionar as VMs.

  1. Execute o comando terraform init para inicializar o diretório e baixar os plugins necessários:
    1

    terraform init
  2. Verifique o formato dos arquivos com terraform fmt:
    1

    terraform fmt
  3. Valide a configuração para garantir que não há erros:
    1

    terraform validate
  4. Faça o planejamento da execução (opcional, mas recomendável):
    1

    terraform plan
  5. Execute o terraform apply para provisionar as VMs:
    1

    terraform apply

    Isso irá provisionar as VMs conforme configurado nos arquivos anteriores.

Parte 3: Redirecionamento de Porta para Acesso às VMs

Após a criação das VMs, você precisará configurar o redirecionamento de portas no host de virtualização (KVM) para acessar as VMs externamente.

3.1 - Redirecionamento de Porta para dca-manager

Execute os seguintes comandos no host de virtualização (192.168.0.250) para redirecionar a porta 1022 para a VM dca-manager:

1
2

sudo iptables -I FORWARD -o virbr2 -p tcp -d 10.4.5.10 --dport 22 -j ACCEPT
sudo iptables -t nat -I PREROUTING -p tcp --dport 1022 -j DNAT --to 10.4.5.10:22

3.2 - Redirecionamento de Porta para dca-wk-01

1
2

sudo iptables -I FORWARD -o virbr2 -p tcp -d 10.4.5.11 --dport 22 -j ACCEPT
sudo iptables -t nat -I PREROUTING -p tcp --dport 1122 -j DNAT --to 10.4.5.11:22

3.3 - Redirecionamento de Porta para dca-wk-02

1
2

sudo iptables -I FORWARD -o virbr2 -p tcp -d 10.4.5.12 --dport 22 -j ACCEPT
sudo iptables -t nat -I PREROUTING -p tcp --dport 1222 -j DNAT --to 10.4.5.12:22

3.4 - Redirecionamento de Porta para dca-registry

1
2

sudo iptables -I FORWARD -o virbr2 -p tcp -d 10.4.5.13 --dport 22 -j ACCEPT
sudo iptables -t nat -I PREROUTING -p tcp --dport 1322 -j DNAT --to 10.4.5.13:22

Agora, você pode acessar cada VM usando o IP do host de virtualização e as portas redirecionadas.

Parte 4: Instalação do Ansible e Configuração do Inventário

Com as VMs provisionadas e o redirecionamento de portas configurado, agora vamos instalar o Ansible na máquina de gerenciamento e configurar o inventário para gerenciar as VMs provisionadas.

4.1 - Atualizando o Sistema e Instalando o Ansible

Vamos começar instalando o Ansible na máquina que fará o gerenciamento (Ansible/Terraform host: 192.168.0.100).

  1. Atualize os pacotes do sistema:
    1

    sudo apt update && sudo apt upgrade -y
  2. Instale o repositório do Ansible:
    1
2

    sudo apt install software-properties-common -y
sudo add-apt-repository --yes --update ppa:ansible/ansible
  3. Instale o Ansible e o sshpass (usado para copiar chaves SSH):
    1

    sudo apt install ansible sshpass -y
  4. Verifique a instalação do Ansible:
    1

    ansible --version

4.2 - Configurando a Conexão SSH

Agora precisamos configurar as chaves SSH para acessar as VMs via Ansible. Vamos gerar uma chave SSH e distribuí-la para as VMs usando as portas redirecionadas configuradas anteriormente.

  1. Crie um diretório para armazenar os arquivos do projeto:
    1
2

    mkdir ~/dca
cd ~/dca
  2. Gere uma chave SSH específica para este projeto:
    1

    ssh-keygen -t ed25519 -f dca
  3. Copie a chave pública para cada VM, utilizando as portas redirecionadas no host de virtualização (KVM):
    1
2
3
4

    ssh-copy-id -p 1022 -i dca.pub gean@192.168.0.250
ssh-copy-id -p 1122 -i dca.pub gean@192.168.0.250
ssh-copy-id -p 1222 -i dca.pub gean@192.168.0.250
ssh-copy-id -p 1322 -i dca.pub gean@192.168.0.250

4.3 - Configuração do Inventário do Ansible

Agora vamos configurar o inventário do Ansible para que ele saiba quais VMs gerenciar.

  1. Crie um arquivo chamado hosts dentro do diretório ~/dca:
    1

    vim hosts
  2. Adicione o seguinte conteúdo, especificando as VMs e suas portas redirecionadas:
    1
2
3
4
5
6
7
8
9
10
11
12
13
14

    [manager]
dca-manager ansible_host=192.168.0.250 ansible_port=1022

[wk01]
dca-wk-01 ansible_host=192.168.0.250 ansible_port=1122

[wk02]
dca-wk-02 ansible_host=192.168.0.250 ansible_port=1222

[registry]
dca-registry ansible_host=192.168.0.250 ansible_port=1322

[all:vars]
ansible_python_interpreter=/usr/bin/python3

4.4 - Configuração do Arquivo ansible.cfg

Agora precisamos configurar o arquivo ansible.cfg para garantir que ele use as chaves SSH corretas e não faça a verificação da chave de host (para evitar prompts durante a execução).

  1. Crie o arquivo ansible.cfg dentro do diretório ~/dca:
    1

    vim ansible.cfg
  2. Adicione o conteúdo abaixo:
    1
2
3
4
5

    [defaults]
inventory = hosts
remote_user = gean
host_key_checking = False
private_key_file = dca

4.5 - Testando a Comunicação com as VMs

Agora que tudo está configurado, vamos testar a conectividade entre o Ansible e as VMs.

  1. Execute o comando de ping para testar a comunicação com todas as VMs:
    1

    ansible all -m ping

    Se a configuração estiver correta, você deverá ver uma resposta de cada VM, semelhante a esta:

    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

    dca-manager | SUCCESS => {
    "changed": false,
    "ping": "pong"
}
dca-wk-01 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}
dca-wk-02 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}
dca-registry | SUCCESS => {
    "changed": false,
    "ping": "pong"
}

Parte 5: Playbook para Instalar o Docker

Agora que o Ansible está configurado e funcionando corretamente, vamos criar um playbook para instalar o Docker nas VMs. O playbook identificará automaticamente se o sistema é Ubuntu ou Oracle Linux e instalará as dependências corretas.

5.1 - Consultando o Sistema Operacional das VMs

Antes de escrever o playbook completo, é útil confirmar quais sistemas operacionais estão rodando em cada VM.

  1. Verifique a distribuição e versão no dca-registry:
    1
2

    ansible dca-registry -m ansible.builtin.setup -a "filter=distribution"
ansible dca-registry -m ansible.builtin.setup -a "filter=ansible_distribution_version"

5.2 - Criando o Playbook de Instalação do Docker

Agora, vamos criar o playbook para instalar o Docker em todas as VMs.

  1. Crie o arquivo playbook.yml:
    1

    vim playbook.yml

  2. Adicione o conteúdo abaixo:

    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

    ---
- name: Instalar Docker no Ubuntu 22.04 e Oracle Linux 9
  hosts: all
  become: yes
  tasks:

    - name: Verificar o sistema operacional
      ansible.builtin.setup:
        gather_subset:
          - "os_family"

    # Dependências para Ubuntu 22.04
    - name: Instalar dependências no Ubuntu 22.04
      apt:
        name:
          - apt-transport-https
          - ca-certificates
          - curl
          - software-properties-common
        state: present
        update_cache: yes
      when: ansible_facts['distribution'] == 'Ubuntu' and ansible_facts['distribution_version'] == '22.04'

    - name: Baixar chave GPG do Docker no Ubuntu
      apt_key:
        url: https://download.docker.com/linux/ubuntu/gpg
        state: present
      when: ansible_facts['distribution'] == 'Ubuntu' and ansible_facts['distribution_version'] == '22.04'

    - name: Adicionar repositório do Docker no Ubuntu
      apt_repository:
        repo: deb https://download.docker.com/linux/ubuntu  stable
        state: present
      when: ansible_facts['distribution'] == 'Ubuntu' and ansible_facts['distribution_version'] == '22.04'

    # Dependências para Oracle Linux 9.4
    - name: Instalar dependências no Oracle Linux 9.4
      dnf:
        name: dnf-utils
        state: present
      when: ansible_facts['distribution'] == 'OracleLinux' and ansible_facts['distribution_version'] == '9.4'

    - name: Verificar se o repositório Docker já existe no Oracle Linux
      stat:
        path: /etc/yum.repos.d/docker-ce.repo
      register: docker_repo_exists
      ignore_errors: yes
      when: ansible_facts['distribution'] == 'OracleLinux' and ansible_facts['distribution_version'] == '9.4'

    - name: Adicionar repositório do Docker no Oracle Linux
      command: dnf config-manager --add-repo https://download.docker.com/linux/rhel/docker-ce.repo
      when: docker_repo_exists.stat is defined and not docker_repo_exists.stat.exists and ansible_facts['distribution'] == 'OracleLinux' and ansible_facts['distribution_version'] == '9.4'

    # Instalar Docker em ambas as distribuições
    - name: Instalar Docker e pacotes relacionados
      package:
        name:
          - docker-ce
          - docker-ce-cli
          - containerd.io
          - docker-compose-plugin
        state: latest
      when: ansible_facts['os_family'] in ['Debian', 'RedHat']

    # Iniciar e habilitar o Docker
    - name: Habilitar e iniciar serviço Docker
      service:
        name: docker
        enabled: true
        state: started

    # Adicionar o usuário ao grupo Docker
    - name: Adicionar usuário ao grupo Docker
      user:
        name: gean
        groups: docker
        append: yes

5.3 - Executando o Playbook

Agora, execute o playbook para instalar o Docker nas VMs:

1

ansible-playbook playbook.yml

5.4 - Verificando a Instalação

Verifique se o Docker foi instalado corretamente executando o comando abaixo em uma das VMs:

1
2

ansible dca-manager -m shell -a "docker --version"
ansible dca-registry -m shell -a "docker --version"

Se tudo estiver correto, você verá a versão do Docker instalada em cada VM.

DevOps, Ansible, Terraform, Docker, KVM, Automação, Infraestrutura como Código
KVM Terraform Ansible Docker Automação Infraestrutura
This post is licensed under CC BY 4.0 by the author.