Observação:

Gerenciar Máquinas Virtuais KVM usando o Oracle Linux Automation Manager

Introdução

O conjunto community.libvirt fornece módulos e plug-ins de libvirt suportados pela comunidade de libvirt do Ansible. Esses módulos e plug-ins ajudam a gerenciar máquinas virtuais (VMs) e contêineres usando a API libvirt.

Objetivos

Neste tutorial, você aprenderá a:

Pré-requisitos

Observação: Para obter detalhes sobre como instalar o Oracle Linux Automation Manager ou o KVM, consulte os links no final deste laboratório.

Implantar o Oracle Linux Automation Manager

Observação: Se estiver em execução em sua própria tenancy, leia o projeto linux-virt-labs GitHub README.md e conclua os pré-requisitos antes de implantar o ambiente de laboratório.

  1. Abra um terminal no Luna Desktop.

  2. Clone o projeto linux-virt-labs GitHub.

    git clone https://github.com/oracle-devrel/linux-virt-labs.git

  3. Altere para o diretório de trabalho.

    cd linux-virt-labs/olam

  4. Instale as coleções necessárias.

    ansible-galaxy collection install -r requirements.yml

  5. Atualize a configuração da instância do Oracle Linux.

    cat << EOF | tee instances.yml > /dev/null
compute_instances:
  1:
    instance_name: "olam-node"
    type: "control"
  2:
    instance_name: "git-server"
    type: "server"
  3:
    instance_name: "kvm-server"
    type: "server"
passwordless_ssh: true
use_git: true
use_kvm: true
EOF

  6. Implante o ambiente de laboratório.

    ansible-playbook create_instance.yml -e ansible_python_interpreter="/usr/bin/python3.6" -e "@instances.yml"

    O ambiente de laboratório gratuito requer a variável extra ansible_python_interpreter porque instala o pacote RPM do SDK para Python do Oracle Cloud Infrastructure. O local para a instalação deste pacote está sob os módulos python3.6.

    A forma de implantação padrão usa a CPU AMD e o Oracle Linux 8. Para usar uma CPU Intel ou Oracle Linux 9, adicione -e instance_shape="VM.Standard3.Flex" ou -e os_version="9" ao comando de implantação.

    Importante: Aguarde a execução bem-sucedida do playbook e atinja a tarefa de pausa. A instalação do Oracle Linux Automation Manager está concluída neste estágio do manual e as instâncias estão prontas. Tome nota da reprodução anterior, que imprime os endereços IP públicos e privados dos nós que implanta.

Criar um Playbook

  1. Abra uma nova janela do terminal.

  2. Defina uma variável para a instância remota do git-server.

    export REMOTE=<ip_address_of_instance>

  3. Crie o diretório do projeto.

    mkdir ~/olamkvm

  4. Crie um arquivo de requisitos.

    O Oracle Linux Automation Engine usa o arquivo de requisitos para extrair quaisquer coleções ou funções necessárias para o projeto no runtime.

    cat << EOF > ~/olamkvm/requirements.yml 
---
collections:
  - name: community.libvirt
  - name: community.general
  - name: community.crypto
EOF

  5. Crie um arquivo de variáveis.

    O arquivo armazena variáveis e seus valores padrão. O playbook importa esse arquivo no runtime.

    1. Crie um diretório para armazenar o arquivo.

      mkdir ~/olamkvm/vars

    2. Crie o arquivo.

      cat << EOF > ~/olamkvm/vars/defaults.yml
---
username: oracle
base_image_name: OL9U5_x86_64-kvm-b253.qcow2
base_image_url: https://yum.oracle.com/templates/OracleLinux/OL9/u5/x86_64/
base_image_sha: 3b00bbbefc8e78dd28d9f538834fb9e2a03d5ccdc2cadf2ffd0036c0a8f02021
libvirt_pool_dir: "/var/lib/libvirt/images"
vm_name: ol9-dev
vm_vcpus: 2
vm_ram_mb: 2048
vm_net: default
vm_root_pass: 
cleanup_tmp: no 
EOF

  6. Crie os modelos cloud-init.

    Esses modelos criam os arquivos meta-data e user-data para provisionar a configuração da VM via cloud-init.

    1. Criar um diretório para armazenar os modelos.

      mkdir ~/olamkvm/templates

    2. Crie o modelo de metadados.

      cat << EOF > ~/olamkvm/templates/meta-data.j2
instance-id: iid-local01
local-hostname: 
EOF

    3. Crie o modelo de dados do usuário.

      cat << EOF > ~/olamkvm/templates/user-data.j2
#cloud-config

system_info:
  default_user:
    name: opc

ssh_authorized_keys:
  - 
EOF

  7. Crie o modelo de definição de VM libvirt.

    cat << EOF > ~/olamkvm/templates/vm-template.xml.j2
<domain type="kvm">
  <name></name>
  <memory unit='MiB'></memory>
  <vcpu placement='static'></vcpu>
  <os>
    <type arch="x86_64" machine="q35">hvm</type>
    <boot dev="hd"/>
  </os>
  <features>
    <acpi/>
    <apic/>
  </features>
  <cpu mode="host-model"/>
  <clock offset="utc">
    <timer name="rtc" tickpolicy="catchup"/>
    <timer name="pit" tickpolicy="delay"/>
    <timer name="hpet" present="no"/>
  </clock>
  <pm>
    <suspend-to-mem enabled="no"/>
    <suspend-to-disk enabled="no"/>
  </pm>
  <devices>
    <emulator>/usr/libexec/qemu-kvm</emulator>
    <disk type="file" device="disk">
      <driver name="qemu" type="qcow2"/>
      <source file="/.qcow"/>
      <target dev="vda" bus="virtio"/>
    </disk>
    <disk type="file" device="cdrom">
      <driver name="qemu" type="raw"/>
      <source file="/.iso"/>
      <target dev="sda" bus="sata"/>
      <readonly/>
    </disk>
    <controller type="usb" model="qemu-xhci" ports="15"/>
    <interface type="network">
      <source network=""/>
      <model type="virtio"/>
    </interface>
    <console type="pty"/>
    <channel type="unix">
      <source mode="bind"/>
      <target type="virtio" name="org.qemu.guest_agent.0"/>
    </channel>
    <memballoon model="virtio"/>
    <rng model="virtio">
      <backend model="random">/dev/urandom</backend>
    </rng>
  </devices>
</domain>
EOF

  8. Crie um playbook.

    Este playbook consulta o servidor KVM para VMs existentes e, em seguida, implanta uma nova Imagem do Oracle Linux Cloud.

    cat << EOF > ~/olamkvm/create_vm.yml
---
- name: Create vm with community.libvirt collection
  hosts: kvm
  become: true

  vars_files:
    - vars/defaults.yml

  tasks:

  - name: Add python lxml module required by libvirt ansible module
    ansible.builtin.dnf:
      name: python3-lxml
      state: present

  - name: Get list of existing VMs
    community.libvirt.virt:
      command: list_vms
    register: existing_vms
    changed_when: false

  - name: Print list of existing VMs
    ansible.builtin.debug:
      var: existing_vms

  - name: Create VM when not exist
    when: ( vm_name not in existing_vms.list_vms )
    block:

    - name: Download base image
      ansible.builtin.get_url:
        url: ""
        dest: "/tmp/"
        checksum: "sha256:"
        mode: "0664"

    - name: Copy base image to libvirt directory
      ansible.builtin.copy:
        dest: "/.qcow"
        src: "/tmp/"
        force: false
        remote_src: true 
        owner: qemu
        group: qemu
        mode: "0660"
      register: copy_results

    - name: Generate a vm ssh keypair
      community.crypto.openssh_keypair:
        path: ~/.ssh/id_rsa
        size: 2048
        comment: vm ssh keypair
      register: vm_ssh_keypair
      become: true
      become_user: ""

    - name: Create vm meta-data
      ansible.builtin.template:
        src: templates/meta-data.j2
        dest: "~/meta-data"
        mode: "0664"
      become_user: ""

    - name: Read the vm ssh private key
      ansible.builtin.slurp:
        src: "~/.ssh/id_rsa.pub"
      register: vm_ssh_private_key
      become: true
      become_user: ""

    - name: Create var for private key
      ansible.builtin.set_fact:
        vm_private_key: ""

    - name: Create vm user-data
      ansible.builtin.template:
        src: templates/user-data.j2
        dest: ~/user-data
        mode: "0664"
      become: true
      become_user: ""

    - name: Generate iso containing cloud-init configuration
      ansible.builtin.shell: |
        genisoimage -output /tmp/.iso -volid cidata -joliet -rock ~/user-data ~/meta-data
      become: true
      become_user: ""
      register: generate_iso
      changed_when: generate_iso.rc == 0

    - name: Copy vm iso image to libvirt directory
      ansible.builtin.copy:
        dest: "/.iso"
        src: "/tmp/.iso"
        force: false
        remote_src: true 
        owner: qemu
        group: qemu
        mode: "0660"

    - name: Remove vm iso image from tmp
      ansible.builtin.file:
        path: "/tmp/.iso"
        state: absent

    - name: Define the vm
      community.libvirt.virt:
        command: define
        xml: ""

  - name: Start the vm
    community.libvirt.virt:
      name: ""
      state: running
    register: vm_start_results
    until: "vm_start_results is success"
    retries: 15
    delay: 2

  - name: Remove the temporary file
    ansible.builtin.file:
      path: "/tmp/"
      state: absent
    when: cleanup_tmp | bool
EOF

Adicionar o Projeto ao Controle de Origem

  1. Inicialize o diretório de trabalho do projeto em um repositório Git.

    Antes de inicializar o repositório, você precisa executar algumas etapas de configuração de primeira vez do Git.

    1. Defina o nome da ramificação padrão usado ao inicializar um projeto.

      git config --global init.defaultBranch main

    2. Defina sua identidade.

      O e-mail e o nome são exemplos neste tutorial. Use seu email e nome ao trabalhar em seus projetos, pois essas informações são imutavelmente incorporadas a cada commit.

      git config --global user.email johndoe@example.com
git config --global user.name "John Doe"

    3. Altere o diretório de trabalho do projeto.

      cd ~/olamkvm

    4. Inicialize o diretório como um repositório Git local.

      git init

      O comando retorna que inicializou o repositório Git vazio.

  2. Verifique o estado do diretório de trabalho e da área de preparação do projeto.

    git status

    O estado do repositório local indica dois arquivos não rastreados, create_vm.yml e requirements.yml, e os diretórios vars e templates.

  3. Adicione e rastreie os novos arquivos na área de preparação.

    git add --all

    A opção --all adiciona todos os arquivos não rastreados e alterados à área de preparação.

  4. Confirme as alterações atualmente na área de preparação.

    git commit -m 'initial commit'

    A opção -m permite adicionar um comentário às alterações confirmadas.

  5. Crie e inicialize o repositório Git remoto.

    Um repositório remoto é um repositório compartilhado usado por todos os colaboradores do projeto e armazenado em um serviço de hospedagem de código como GitHub ou um servidor auto-hospedado.

    ssh git@$REMOTE "git init -b main --bare /git-server/repos/olamkvm.git"

    A opção -b garante a inicialização do repositório remoto usando uma ramificação chamada main.

  6. Aceite a impressão digital da chave ECDSA digitando yes.

  7. Adicione o novo registro de conexão do repositório remoto.

    Adicionar a conexão remota ao repositório local permite que você a use como um atalho nomeado nos comandos do Git.

    git remote add origin git@$REMOTE:/git-server/repos/olamkvm.git

    O caminho após dois-pontos é a localização do diretório do repositório no servidor Git remoto.

  8. Verifique o registro de conexão recém-adicionado.

    git remote -v

    A saída mostra a origem do registro de conexão apontando para o local do repositório Git remoto para os comandos git fetch e git push.

  9. Envie as alterações do repositório local para o repositório remoto.

    git push origin main

    Agora é possível usar a origem olamkvm em um Projeto do Oracle Linux Automation Manager.

Criar Credenciais do Ansible Galaxy

Essas credenciais permitem que o Oracle Linux Automation Manager extraia a Coleção do OCI Ansible do Ansible Galaxy Hub público.

  1. Abra uma nova janela de terminal e configure um túnel SSH para a instância do nó olam.

    ssh -L 8444:localhost:443 oracle@<ip_address_of_instance>

  2. Abra um navegador da Web e insira o URL.

    https://localhost:8444

    Observação: aprove o aviso de segurança com base no navegador usado. No navegador Chrome, clique no botão Avançado e, em seguida, no link Prosseguir para localhost (inseguro).

  3. Faça login no Oracle Linux Automation Manager WebUI. Use o Nome de Usuário admin e a Senha admin criados durante a implantação automatizada.

    olam2-login

  4. O WebUI é exibido após um log-in bem-sucedido.

    olam2-webui

  5. Clique em Credenciais na seção Recursos no menu de navegação.

  6. Clique no botão Adicionar.

  7. Informe ou selecione os valores a seguir nos campos específicos.

    Para campos com uma pesquisa ou lista de valores, podemos começar a digitar o valor solicitado e selecioná-lo.

    • Nome: My Ansible Galaxy
    • Organização: Default
    • Tipo de Credencial: Token da API do Ansible Galaxy/Automation Hub

    O Oracle Linux Automation Manager usa as credenciais do Ansible Galaxy para permitir o download de atribuições e coleções usando o comando ansible-galaxy.

    • URL do Galaxy Server: https://galaxy.ansible.com

    olam2-telas-galáxia visíveis

  8. Verifique as entradas e clique no botão Salvar.

  9. Clique em Organizações na seção Acesso no menu de navegação.

    A atribuição da credencial do Ansible Galaxy dentro da Organização permite o download da Coleção Ansible do Oracle Linux Infrastructure no projeto git.

  10. Clique na organização Padrão e no botão Editar.

  11. Selecione a opção de pesquisa no campo Credenciais Galaxy.

  12. Selecione Meu Ansible Galaxy na caixa de diálogo pop-up Selecionar Credenciais do Galaxy e clique no botão Selecionar.

  13. Verifique e clique no botão Salvar.

    olam2-ansible-galaxy-org

Criar Credenciais da Máquina

Essas credenciais permitem que o Oracle Linux Automation Manager se conecte ao sistema de virtualização KVM via SSH.

  1. Clique em Credenciais em Recursos no menu de navegação.

  2. Clique no botão Adicionar.

  3. Informe ou selecione os valores a seguir nos campos específicos.

    Para campos com uma pesquisa ou lista de valores, podemos começar a digitar o valor solicitado e selecioná-lo.

    • Nome: My KVM Server
    • Organização: Default
    • Tipo de Credencial: Máquina

    O Oracle Linux Automation Manager usa as credenciais de Máquina para definir as informações necessárias ao estabelecer uma conexão SSH com um host.

    A página é atualizada, solicitando os Detalhes do Tipo.

  4. Informe o Nome do Usuário.

    • Nome do Usuário: oracle

    olam2-telas de máquina

  5. Clique no botão Procurar da Chave Privada SSH.

    Uma caixa de diálogo é exibida exibindo a janela Abrir arquivo.

  6. Clique com o botão direito do mouse no painel central da janela Abrir arquivo e selecione Mostrar arquivos ocultos na caixa de diálogo pop-up.

    olam2-arquivo aberto

  7. Clique em qualquer lugar no painel central para descartar a caixa de diálogo.

  8. Clique no local Home no menu de navegação no lado esquerdo da janela Open File (Abrir arquivo).

  9. Clique duas vezes na pasta .ssh na lista e, em seguida, clique duas vezes no arquivo id_rsa.

    Esta ação copia o conteúdo do arquivo id_rsa para o campo Chave Privada SSH.

  10. Verifique as entradas, role até a parte inferior e clique no botão Salvar.

Criar um Inventário

  1. Clique em Equipamentos no menu de navegação.

  2. Clique no botão Adicionar e selecione Adicionar equipamento na lista suspensa de valores.

  3. Informe ou selecione os valores a seguir nos campos específicos.

    • Nome: KVM Servers
    • Grupos de Instâncias: controlplane

  4. Verifique e clique no botão Salvar.

    olam2-inv

Adicionar um Grupo a um Inventário

Um grupo em um inventário é uma classificação de hosts ou outros grupos que permitem controlar um conjunto de hosts para uma determinada tarefa.

  1. Clique na guia Grupos na página Detalhes dos Servidores KVM.

    olam2-inv-kvm-detalhes

  2. Clique no botão Adicionar.

  3. Informe ou selecione os valores a seguir nos campos específicos.

    • Nome: kvm

  4. Verifique e clique no botão Salvar.

    olam2-kvm-group-details

Adicionar um Host ao Grupo de Inventário

  1. Clique na guia Hosts na página Detalhes do grupo do kvm.

    olam2-kvm-group-details

  2. Clique no botão Adicionar e selecione Adicionar novo host na lista suspensa de valores.

  3. Informe ou selecione os valores a seguir nos campos específicos.

    • Nome: Use o endereço IP público do host kvm-server.

  4. Verifique e clique no botão Salvar.

    olam2-grp-new-host

Fazer Ping no Grupo de Inventário

Use o módulo ping para verificar se o Oracle Linux Automation pode se conectar ao host dentro do grupo de inventário.

  1. Use as trilhas de navegação e clique em Servidores KVM.

  2. Clique na guia Grupos.

  3. Marque a caixa ao lado do grupo kvm e clique no botão Executar Comando.

    A caixa de diálogo pop-up Executar Comando é exibida.

  4. Selecione o módulo ping e clique no botão Próximo.

  5. Selecione o Ambiente de Execução OLAM EE (2.2) e clique no botão Próximo.

  6. Selecione a Credencial de Máquina do Meu Servidor KVM e clique no botão Próximo.

  7. Verifique e clique no botão Iniciar.

    Um job inicia e exibe a saída do módulo ping.

    olam2-kvm-grp-ping

Adicionar Credencial de Controle de Origem

  1. Clique em Credenciais no menu de navegação.

  2. Clique no botão Adicionar.

  3. Informe ou selecione os valores a seguir nos campos específicos.

    • Nome: Git Server
    • Organização: Default
    • Tipo de Credencial: Controle de Origem

    olam2-git-cred1

    A página é atualizada, solicitando os Detalhes do Tipo.

  4. Informe o Nome do Usuário.

    • Nome do Usuário: git

  5. Informe a Chave Privada do SCM

    Clique no botão Procurar e clique duas vezes no arquivo id_rsa. Esta ação copia o conteúdo da chave no campo Chave Privada do SCM.

    olam2-git-cred2

  6. Verifique e clique no botão Salvar.

    olam2-git-cred3

Crie um Projeto

  1. Clique em Projetos no menu de navegação.

  2. Clique no botão Adicionar.

  3. Informe ou selecione os valores a seguir nos campos específicos.

    • Nome: My Project
    • Ambiente de Execução: OLAM EE (2.2)
    • Tipo de Credencial de Controle de Origem: Git

    olam2-proj1

    A página é atualizada, solicitando os Detalhes do Tipo.

  4. Informe o URL remoto do servidor git.

    • URL de Controle de Origem: git@<ip_address_of_instance>:/git-server/repos/olamkvm.git

  5. Selecione Servidor Git para a Credencial de Controle de Origem.

  6. Verifique e clique no botão Salvar.

    olam2-proj2

  7. Verifique o status de sincronização do projeto.

    Após a criação do projeto, o projeto exibirá seu status no resumo Detalhes à medida que a sincronização começar. O status passará de Em Execução para Com Êxito se a configuração estiver correta e o servidor Git estiver acessível.

    olam2-sincronização de projeto

Criar um modelo de trabalho

  1. Clique em Modelos no menu de navegação.

  2. Clique no botão Adicionar e selecione Adicionar modelo de job na lista suspensa de valores.

  3. Informe os valores obrigatórios.

    • Nome: My Template
    • Tipo de Job: Executar
    • Inventory: Servidores KVM
    • Projeto: Meu Projeto
    • Ambiente de Execução: OLAM EE (2.2)
    • Playbook: create_vm.yml
    • Credenciais: Meu Servidor KVM

    olam2-temp1

  4. Revise, role para baixo e clique no botão Salvar.

    olam2-temp2

  5. Inicie o modelo.

    Inicie um job na página de resumo do modelo clicando no botão Iniciar.

    olam2-temp-launch

    Se bem-sucedido, o job será iniciado e exibirá a saída do modelo. A saída padrão mostra o playbook em execução e gera os resultados do playbook.

    olam2-temp-output

Verificar Criação de Máquina Virtual

  1. Abra um terminal e conecte-se via ssh ao nó kvm-server.

    ssh oracle@<ip_address_of_instance>

  2. Obtenha uma lista de VMs em execução.

    sudo virsh list

    Exemplo de Saída:

    [oracle@kvm-server ~]$ sudo virsh list
 Id   Name      State
-------------------------
 1    ol9-dev   running

  3. Obtenha o endereço IP da VM ol9-dev.

    sudo virsh net-dhcp-leases default

    Exemplo de Saída:

    [oracle@kvm-server ~]$ sudo virsh net-dhcp-leases default
 Expiry Time           MAC address         Protocol   IP address           Hostname   Client ID or DUID
------------------------------------------------------------------------------------------------------------
 2023-04-06 18:59:33   52:54:00:6e:93:07   ipv4       192.168.122.167/24   ol9-dev    01:52:54:00:6e:93:07

  4. Conecte-se à VM.

    ssh opc@$(sudo virsh -q domifaddr ol9-dev | awk '{print substr($4, 1, length($4)-3)}')

    O -q remove o cabeçalho da saída dos comandos virsh. O awk extrai a quarta coluna do comando virsh domifaddr e o substr() remove os três últimos caracteres.

  5. Desconecte-se da VM.

    exit

(Opcional) Criar Outra Máquina Virtual

O playbook permite a criação de outra VM alterando a variável vm_name.

  1. Alterne para a janela do navegador que contém o Oracle Linux Automation Manager WebUI e faça log-in, se necessário.

  2. Clique em Modelos no menu de navegação.

  3. Clique no ícone Editar Modelo de Meu Modelo.

    olam2-edição-temp

  4. Adicione a variável vm_name com um valor de ol9-new à seção Variáveis.

    olam2-temp-vars

  5. Role para baixo e clique no botão Salvar.

  6. Inicie o modelo.

  7. Repita as etapas de verificação da máquina virtual e conecte-se à VM recém-criada.

Próximas Etapas

A saída bem-sucedida do job do Oracle Linux Automation Manager e a capacidade de SSH na máquina virtual confirmam que tudo funciona. Experimente ainda mais com a coleção community.libvirt e crie máquinas virtuais no Oracle Linux KVM para expandir sua infraestrutura. Em seguida, tente provisionar essas máquinas virtuais com playbooks adicionais. Confira nosso treinamento adicional na Estação de Treinamento do Oracle Linux.

Mais Recursos de Aprendizagem

Explore outros laboratórios em docs.oracle.com/learn ou acesse mais conteúdo de aprendizado gratuito no canal Oracle Learning YouTube. Além disso, visite education.oracle.com/learning-explorer para se tornar um Oracle Learning Explorer.

Para obter a documentação do produto, visite o Oracle Help Center.