inventory-playbook.yml

#
# Esse playbook assume que o arquivo `/etc/korp/ansible/inventory.yml` já foi criado, e criptografado
# O aqruivo de inventário pode estar vazio, ou com alguns valores já definidos
#
---
- hosts: localhost
  connection: local
  become: true
  vars:
    db_suffix_divider: "_"
    mssql_user: "korp.services"
    cert_directory: "/etc/korp/certs"

    custom_cert_has_pass_file: false
    custom_certs_folder: ""
    certbot_automated_email: ""

    custom_certificate: false
    self_signed_certificate: false
    certbot_automated_certificate: false

    dns_api: ""
    dns_cdn: ""
    dns_frontend: ""

    # valores padrões, podem ser alterados durante o playbook ou durante sua chamada
    alowerd_cert_types: ["selfsigned", "custom", "certbot"]
    https_port: "443"

    # possíveis variaveis que podem ser enviadas para o playbook 
    custom_setup_info:
      cert:
        cert_type: ""
        custom_cert_has_pass: false
        custom_cert_path: ""
        certbot_email: ""
      dns:
        api: ""
        cdn: ""
        frontend: ""
      https_port: ""
      external_reverse_proxy: false

  tasks:

    - name: Importação de inventário
      ansible.builtin.set_fact:
        inventory: "{{ (lookup('ansible.builtin.template', '/etc/korp/ansible/inventory.yml')|from_yaml) }}"
        become: true

    - name: Criação de estrutura do inventário
      block:
        - name: Definição de estrutura de inventario
          ansible.builtin.set_fact:
            inventory:
              all:
                children:
                  nodes:
                    hosts:
                      localhost:
          when: inventory.all.children.nodes.hosts.localhost is not defined

        - name: Definição do atalho do caminho inventário
          ansible.builtin.set_fact:
            shrink_inventory: "{{ inventory.all.children.nodes.hosts.localhost }}"

    - name: Setup SQL Server
      block:
        - name: Coleta de informações
          ansible.builtin.pause:
            prompt: "Para continuar a instalação, digite as seguintes informações sobre o SQL Server:\nPossui 2 servidores para o SQL Server, um para Homologação e outro para Produção?\n(S = sim ou N = não)"
          register: chk_sql
          when: inventory.all.children.nodes.hosts.localhost.mssql.address is not defined 

        - name: Coleta de IP de acesso do SQL Server de Produção e homologação
          block:
            - name: Coleta do ip sql server
              ansible.builtin.pause:
                prompt: "Informe o IP de acesso do SQL Server de Produção"
              register: sql_ip

            - name: Coleta do usuario sql server
              ansible.builtin.pause:
                prompt: "Informe o nome de um usuário com permissões administrativas no SQL Server de Produção"
              register: sql_user

            - name: Coleta da senha sql server
              ansible.builtin.pause:
                prompt: "Informe a senha do usuário administrativo no SQL Server de Produção"
              register: sql_pass

            - name: Coleta do ip testing sql server
              ansible.builtin.pause:
                prompt: "Informe o IP de acesso do SQL Server de Homologação"
              register: testing_sql_ip

            - name: Coleta do nome testing sql server
              ansible.builtin.pause:
                prompt: "Informe o nome de um usuário com permissões administrativas no SQL Server de Homologação"
              register: testing_sql_user

            - name: Coleta da senha testing sql server
              ansible.builtin.pause:
                prompt: "Informe a senha do usuário administrativo no SQL Server de Produção"
              register: testing_sql_pass

            - name: Declaração de variáveis do SQL Server
              ansible.builtin.set_fact: 
                sql_ips: "{{ sql_ip.user_input }}"
                sql_users: "{{ sql_user.user_input }}"
                sql_passs: "{{ sql_pass.user_input }}"
                testing_sql_ip: "{{ testing_sql_ip.user_input }}"
                testing_sql_user: "{{ testing_sql_user.user_input }}"
                testing_sql_pass: "{{ testing_sql_pass.user_input }}"

          when: chk_sql.skipped is not defined and chk_sql.user_input | upper == "S"

        - name: Verificação de testing_mssql
          ansible.builtin.set_fact:
            shrink_inventory: "{{ inventory.all.children.nodes.hosts.localhost | combine(
              {
                'testing_mssql': {
                  'address': shrink_inventory.mssql.address,
                  'default_user': shrink_inventory.mssql.default_user,
                  'default_password': shrink_inventory.mssql.default_password,
                  'korp_user': shrink_inventory.mssql.korp_user,
                  'korp_password': shrink_inventory.mssql.korp_password
                }
              }, recursive=True) }}"
          when: shrink_inventory.mssql is defined and (shrink_inventory.testing_mssql is not defined )

        - name: Coleta de informações para um servidor de SQL Server
          block: # o Bloco trata de apenas um servidor de SQL
            - name: Coleta do ip sql server
              ansible.builtin.pause:
                prompt: "Informe o IP de acesso do SQL Server"
              register: sql_ip

            - name: Coleta do usuario sql server
              ansible.builtin.pause:
                prompt: "Informe o nome de um usuário com permissões administrativas no SQL Server"
              register: sql_user

            - name: Coleta da senha sql server
              ansible.builtin.pause:
                prompt: "Informe a senha do usuário administrativo no SQL Server"
              register: sql_pass

            - name: Declaração de variáveis do SQL Server
              ansible.builtin.set_fact:
                sql_ips: "{{ sql_ip.user_input }}"
                sql_users: "{{ sql_user.user_input }}"
                sql_passs: "{{ sql_pass.user_input }}"
                testing_sql_ip: "{{ sql_ip.user_input }}"
                testing_sql_user: "{{ sql_user.user_input }}"
                testing_sql_pass: "{{ sql_pass.user_input }}"

          when: chk_sql.skipped is not defined and chk_sql.user_input | upper == "N"

        - name: Geração de senha aleatória para SQL Server
          ansible.builtin.set_fact:
            mssql_korp_passRandom: "{{ lookup('community.general.random_string', length=16, special=False) }}"
          when: chk_sql.skipped is not defined

        - name: Definição de usuário do SQL Server
          ansible.builtin.set_fact:
            mssql_user: "{{ mssql_user }}{{ db_suffix_divider }}{{ db_suffix }}"
          when: db_suffix != "" 

    - name: Verificação de sufixo de banco de dados
      ansible.builtin.set_fact:
        db_suffix: ""
      when: db_suffix is not defined

    - name: Configuração de application Server
      block:
        - name: Coleta de ip do servidor de aplicação 
          ansible.builtin.pause:
            prompt: "Agora, informe o IP do Servidor de aplicações Windows: (ou pressione enter para usar {{ sql_ips }})"
          register: application_server_address

        - name: Declaração da variavel servidor de aplicação 
          ansible.builtin.set_fact:
            application_server_address: "{{ application_server_address.user_input }}"

        - name: Verificação do servidor de aplicação 
          ansible.builtin.set_fact:
            application_server_address: "{{ sql_ips }}"
          when: application_server_address == ""

      when: chk_sql.skipped is not defined

    - name: Setup de certificados
      block:
        - name: Verificação de arquivos de certificados
          ansible.builtin.stat:
            path: "{{ cert_directory }}/cert.crt"
          register: cert_file_status

        - name: Definição de configurações de certificado
          block:
            - name: Setup de certificado iterativo
              block:
                - name: Coleta de informações
                  ansible.builtin.pause:
                    prompt: "
                      Selecione a modalidade de certificado:\n
                        1) Certificado AutoAssinado                 - padrão\n
                        2) Certificado Customizado                  - necessário domínio próprio e arquivos de certificado\n
                        3) Certificado Automático com LestEncrypt   - necessário domínio próprio
                      "
                  register: chk_cert

                - name: Verificação de resposta
                  ansible.builtin.fail:
                    msg: "Valor informado não reconhecido"
                  when: chk_cert.user_input not in ["1","2","3"]

                - name: Setup de 'Certificado Customizado'
                  block:
                    - name: Coleta de informações de arquivo de senha
                      ansible.builtin.pause:
                        prompt: "O certificado contém senha(cert.pass)? (S = sim ou N = não)"
                      register: chk_cert_pass

                    - name: Definição de custom_cert_has_pass_file
                      ansible.builtin.set_fact:
                        custom_cert_has_pass_file: "{{ chk_cert_pass.user_input | upper == 'S' }}"

                    - name: Leitura de pasta de certificados
                      ansible.builtin.pause:
                        prompt: "Digite o camiho absoluto da pasta com os arquivos de certifiaco. O nome dos aquivos de certificado na pasta devem ser exatamente: cert.crt, cert.key, cert.pass(caso exista)"
                      register: custom_certs_folder_return

                    - name: Definição de caminho de pasta de certificados
                      ansible.builtin.set_fact:
                        custom_certs_folder: "{{ custom_certs_folder_return.user_input }}"

                  when: chk_cert.user_input == "2"

                - name: Setup de 'Certificado Automático com LestEncrypt'
                  block:
                    - name: Coleta de email
                      ansible.builtin.pause:
                        prompt: "Informe o email que será utilizado para criar o certificado."
                      register: chk_certbot_automated_email

                    - name: Verificação de resposta
                      ansible.builtin.fail:
                        msg: "Valor informado está vazio"
                      when: chk_certbot_automated_email.user_input == ""

                    - name: Definição de certbot_automated_email
                      ansible.builtin.set_fact:
                        certbot_automated_email: "{{ chk_certbot_automated_email.user_input }}"

                  when: chk_cert.user_input == "3"

                - name: Definição de tipo de certificado
                  ansible.builtin.set_fact:
                    self_signed_certificate: "{{ chk_cert.user_input == '1' }}"
                    custom_certificate: "{{ chk_cert.user_input == '2' }}"
                    certbot_automated_certificate: "{{ chk_cert.user_input == '3' }}"

              when: custom_setup_info.cert.cert_type == ""

            - name: Setup de certificados por linha de comando
              block:
                - name: Verificação de cert_type
                  ansible.builtin.fail:
                    msg: "O valor de 'cert_type' não é válido."
                  when: not custom_setup_info.cert.cert_type in alowerd_cert_types

                - name: Setup de 'Certificado Customizado'
                  block:
                    - name: Garantia de definição de flags
                      ansible.builtin.fail:
                        msg: "Uma ou mais flag de configuração de certificado não foram passadass, ou estão vazias."
                      when: custom_setup_info.cert.custom_cert_has_pass == "" or custom_setup_info.cert.custom_cert_path == ""

                  when: custom_setup_info.cert.cert_type == "custom"

                - name: Setup de 'Certificado Automático com LestEncrypt'
                  block:
                    - name: Garantia de definição de flags
                      ansible.builtin.fail:
                        msg: "Uma ou mais flag de configuração de certificado não foram passadass, ou estão vazias."
                      when: custom_setup_info.cert.certbot_email == ""

                  when: custom_setup_info.cert.cert_type == "certbot"

                - name: Definição de variáveis
                  ansible.builtin.set_fact:
                    custom_certificate: "{{ custom_setup_info.cert.cert_type == 'custom' | bool }}"
                    self_signed_certificate: "{{ custom_setup_info.cert.cert_type == 'selfsigned' | bool }}"
                    certbot_automated_certificate: "{{ custom_setup_info.cert.cert_type == 'certbot' | bool }}"
                    custom_cert_has_pass_file: "{{ custom_setup_info.cert.custom_cert_has_pass | bool }}"
                    custom_certs_folder: "{{ custom_setup_info.cert.custom_cert_path }}"
                    certbot_automated_email: "{{ custom_setup_info.cert.certbot_email }}"

              when: custom_setup_info.cert.cert_type != ""

            - name: Setup de certificados
              block:
                - name: Setup padrão de certificado customizado
                  block:
                    - name: Garantia de "/" no caminho da pasta de certificados
                      ansible.builtin.set_fact:
                        custom_certs_folder: "{{ custom_certs_folder[:-1] }}"
                      when: custom_certs_folder | last == "/"

                    - name: "Leitura de diretório informado"
                      ansible.builtin.stat:
                        path: "{{ custom_certs_folder }}/cert.crt"
                      register: cert_crt_file_status

                    - name: "Leitura de diretório informado"
                      ansible.builtin.stat:
                        path: "{{ custom_certs_folder }}/cert.key"
                      register: cert_key_file_status

                    - name: "Leitura de diretório informado"
                      ansible.builtin.stat:
                        path: "{{ custom_certs_folder }}/cert.pass"
                      register: cert_pass_file_status
                      when: custom_cert_has_pass_file

                    - name: Garantia de existência de arquivos de certificado
                      ansible.builtin.fail:
                        msg: "Um ou mais arquivos de certificado não foram encontrados no caminho passado ({{ custom_certs_folder }})."
                      when: not (cert_crt_file_status.stat.exists and cert_key_file_status.stat.exists) or (custom_cert_has_pass_file and not cert_pass_file_status.stat.exists)

                    - name: Criação do diretório em que as os arquivos de certificado ficarão
                      ansible.builtin.file:
                        path: "{{ cert_directory }}/"
                        state: directory
                        mode: '0755'

                    - name: Copia de arquivos de certificado
                      ansible.builtin.copy:
                        dest: "{{ cert_directory }}/{{ item }}"
                        src: "{{ custom_certs_folder }}/{{ item }}"
                        # owner e permissões dos arquivos serão alteradas depois
                        owner: root
                        group: root
                        mode: '0777'
                      when: item != "cert.pass" or custom_cert_has_pass_file
                      loop:
                        - "cert.crt"
                        - "cert.key"
                        - "cert.pass"

                  when: custom_certificate

          when: not cert_file_status.stat.exists and (shrink_inventory.certs is undefined)

        - name: Definição de variáveis de certificado
          ansible.builtin.set_fact:
            custom_certificate: false
            self_signed_certificate: true
            certbot_automated_certificate: false
            custom_cert_has_pass_file: false
          when: cert_file_status.stat.exists and (shrink_inventory.certs is undefined)

    - name: Setup de DNS
      block:

        - name: Verificação de número de DNSs definidos
          ansible.builtin.set_fact:
            undefined_dns_num: "{{ [custom_setup_info.dns.api == '', custom_setup_info.dns.cdn == '', custom_setup_info.dns.frontend == ''] | select() | list | length }}"

        - name: Definição de valores de DNS padrão
          ansible.builtin.set_fact:
            dns_api: "korp-api.local"
            dns_cdn: "korp-cdn.local"
            dns_frontend: "korp.local"
          when: undefined_dns_num == "3"

        - name: Verificação de DNS customizado
          ansible.builtin.fail:
            msg: "Nem todos os DNSs customizados foram definidos"
          when: undefined_dns_num != "0" and undefined_dns_num != "3"

        - name: Definição de valores de DNS padrão
          ansible.builtin.set_fact:
            dns_api: "{{ custom_setup_info.dns.api }}"
            dns_cdn: "{{ custom_setup_info.dns.cdn }}"
            dns_frontend: "{{ custom_setup_info.dns.frontend }}"
          when: undefined_dns_num == "0"

      when: shrink_inventory.dns is undefined

    - name: Definição de porta HTTPS
      ansible.builtin.set_fact:
        https_port: "{{ custom_setup_info.https_port }}"
      when: custom_setup_info.https_port != ''

    - name: Definição de nova senha aleatória para postgres
      ansible.builtin.set_fact:
        postgres_new_pass: "{{ lookup('community.general.random_string', length=16, special=False) }}"
        postgres_password_was_updated: false

  # Esta task verifica se a senha padrão 'postgres' no inventário será sobrescrita pela variável 'postgres_new_pass' criada anteriormente.
    - name: Substituição da senha do postgres, caso esteja com a senha padrão 'postgres'
      block:
        - name: Alteração da senha na database
          community.postgresql.postgresql_user:
            db: postgres
            login_host: "{{ shrink_inventory.postgres.address }}"
            login_user: "{{ shrink_inventory.postgres.default_user }}"
            login_password: "{{ shrink_inventory.postgres.default_password }}"
            name: "{{ shrink_inventory.postgres.default_user }}"
            password: "{{ postgres_new_pass }}"
          register: db_password

        - name: Definição da variável para permitir atualização
          ansible.builtin.set_fact:
            # Após o sucesso da alteração na database, alteramos o valor de 'postgres_password_was_updated'
            # para que 'shrink_inventory.postgres.default_password' possa ser sobrescrita na task "Definição dos valores de inventário".
            postgres_password_was_updated: true
          when: db_password.changed
      when: 
        - shrink_inventory.postgres.default_password is defined 
        - shrink_inventory.postgres.default_password == 'postgres'
        
    # Todas as variáveis do inventário são definidas nessa tasks
    # Caso a propriedade já tenha um valor, ele não será alterado
    # caso o valor da propriedade seja nulo (nunca foi definido), irá utilizar a função `default`, inserindo o valor desejado

    - name: Definição dos valores de inventário
      ansible.builtin.set_fact:
        shrink_inventory: "{{ inventory.all.children.nodes.hosts.localhost | combine(
          {
            'app_server': {
              'address': shrink_inventory.app_server.address | default ( application_server_address )
            },
            'linux_korp': {
              'user': shrink_inventory.linux_korp.user | default ('korp'),
              'password': shrink_inventory.linux_korp.password | default (lookup('community.general.random_string', length=16, special=False))
            },
            'mssql': {
              'address': shrink_inventory.mssql.address | default (sql_ips),
              'default_user': shrink_inventory.mssql.default_user | default (sql_users),
              'default_password': shrink_inventory.mssql.default_password | default (sql_passs),
              'korp_user': shrink_inventory.mssql.korp_user | default (mssql_user),
              'korp_password': shrink_inventory.mssql.korp_password | default (mssql_korp_passRandom)
            },
            'testing_mssql': {
              'address': shrink_inventory.testing_mssql.address | default (testing_sql_ip),
              'default_user': shrink_inventory.testing_mssql.default_user | default (testing_sql_user),
              'default_password': shrink_inventory.testing_mssql.default_password | default (testing_sql_pass),
              'korp_user': shrink_inventory.testing_mssql.korp_user | default (mssql_user),
              'korp_password': shrink_inventory.testing_mssql.korp_password | default (mssql_korp_passRandom)
            },
            'rabbitmq': {
              'korp_user': shrink_inventory.rabbitmq.korp_user | default ('korp.services'),
              'korp_password': shrink_inventory.rabbitmq.korp_password | default (lookup('community.general.random_string', length=16, special=False))
            },
            'redis': {
              'password': shrink_inventory.redis.password | default (lookup('community.general.random_string', length=16, special=False))
            },
            'postgres': {
              'address': shrink_inventory.postgres.address | default ('127.0.0.1'),
              'default_user': shrink_inventory.postgres.default_user | default ('postgres') ,
              'default_password': shrink_inventory.postgres.default_password | default (lookup('community.general.random_string', length=16, special=False)) if(not postgres_password_was_updated) else postgres_new_pass,
              'korp_user': shrink_inventory.postgres.korp_user |  default ('korp.services') ,
              'korp_password': shrink_inventory.postgres.korp_password | default (lookup('community.general.random_string', length=16, special=False))
            },
            'minio': {
              'access_key': shrink_inventory.minio.access_key | default (lookup('community.general.random_string', length=16, special=False)),
              'secret_key': shrink_inventory.minio.secret_key| default (lookup('community.general.random_string', length=16, special=False))
            },
            'minio_new': {
              'access_key': shrink_inventory.minio_new.access_key | default (lookup('community.general.random_string', length=16, special=False)),
              'secret_key': shrink_inventory.minio_new.secret_key | default (lookup('community.general.random_string', length=16, special=False))
            },
            'general': {
              'introspection_secret': shrink_inventory.general.introspection_secret | default ( 1000 | random | to_uuid | upper )
            },
            'docker_servicos_network_ip_address_start': shrink_inventory.docker_servicos_network_ip_address_start | default('172.18'),
            'db_suffix_divider': shrink_inventory.db_suffix_divider | default(db_suffix_divider),
            'db_suffix': shrink_inventory.db_suffix | default(db_suffix),
            'certs': {
              'custom': {
                'certificate': shrink_inventory.certs.custom.certificate | default(custom_certificate),
                'has_pass_file': shrink_inventory.certs.custom.has_pass_file | default(custom_cert_has_pass_file)
              },
              'self_signed': {
                'certificate': shrink_inventory.certs.self_signed.certificate | default(self_signed_certificate),
                'passphrase':  shrink_inventory.certs.self_signed.passphrase | default ('korp')
              },
              'certbot_automated': {
                'certificate': shrink_inventory.certs.certbot_automated.certificate | default(certbot_automated_certificate),
                'email': shrink_inventory.certs.certbot_automated.email | default(certbot_automated_email)
              },
              'pfx_passphrase': shrink_inventory.certs.pfx_passphrase | default ('korp')
            },
            'dns': {
              'api': shrink_inventory.dns.api | default (dns_api),
              'cdn': shrink_inventory.dns.cdn | default (dns_cdn),
              'frontend': shrink_inventory.dns.frontend | default (dns_frontend)
            },
            'https_port': shrink_inventory.https_port | default (https_port),
            'reverse_proxy': {
              'external': reverse_proxy.external | default (custom_setup_info.external_reverse_proxy),
              'use_local_for_containers': reverse_proxy.use_local_for_containers | default (true),
              'http_ports': {
                'api': reverse_proxy.http_ports.api | default ('9875'),
                'cdn': reverse_proxy.http_ports.cdn | default ('9876'),
                'frontend': reverse_proxy.http_ports.frontend | default ('9877')
              }
            }
          }, recursive=True) }}"

    - name: Ajuste de estrutura do inventário
      ansible.builtin.set_fact:
        inventory:
          all:
            children:
              nodes:
                hosts:
                  localhost: "{{ shrink_inventory }}"

      #Funcao de inserir a variavel no arquivo.
    - name: Escrita do arquivo de inventário
      copy:
        content: "{{inventory | to_nice_yaml(indent=2) }}"
        dest: /etc/korp/ansible/inventory.yml
        mode: '0644'
      delegate_to: localhost