Observação:

Este tutorial está disponível em um ambiente de laboratório gratuito fornecido pela Oracle.
Ele usa valores de exemplo para credenciais, tenancy e compartimentos do Oracle Cloud Infrastructure. Ao concluir seu laboratório, substitua esses valores por valores específicos do seu ambiente de nuvem.

Execute Tarefas do Oracle Linux com o Oracle Linux Automation Engine

Introdução

O Oracle Linux Automation Engine permite que os administradores automatizem a configuração inicial do Oracle Linux e executem outros jobs administrativos usando uma ferramenta de gerenciamento de configuração de Infraestrutura como código (IaC) por meio de uma série de playbooks e tarefas.

Objetivos

Neste tutorial, você aprenderá a:

Escreva playbooks que:
- Criar um usuário
- Adiciona o usuário ao grupo sudo
- Copia uma chave pública SSH local para o arquivo authorized_keys do usuário
- Adiciona um repositório DNF e instala um pacote
- Manipula arquivos

Pré-requisitos

Um mínimo de dois sistemas Oracle Linux com a seguinte configuração:
- um usuário não raiz com permissões sudo
- par de chaves ssh para o usuário não raiz
- a capacidade de SSH de um host para outro usando um login SSH sem senha

Implemente o Oracle Linux Automation Engine

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.

Abra um terminal no Luna Desktop.

Clone o projeto linux-virt-labs GitHub.

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

Altere para o diretório de trabalho.
```
cd linux-virt-labs/olam
```

Instale as coleções necessárias.

ansible-galaxy collection install -r requirements.yml

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

cat << EOF | tee instances.yml > /dev/null
compute_instances:
  1:
    instance_name: "ol-control-node"
    type: "control"
  2:
    instance_name: "ol-host"
    type: "remote"
use_olae_only: true
EOF

Implante o ambiente de laboratório.
```
ansible-playbook create_instance.yml -e localhost_python_interpreter="/usr/bin/python3.6" -e "@instances.yml"
```
O ambiente de laboratório gratuito requer a variável extra local_python_interpreter, que define ansible_python_interpreter para execuções em execução no localhost. Essa variável é necessária porque o ambiente instala o pacote RPM do SDK para Python do Oracle Cloud Infrastructure, localizado nos 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. Nesta fase do manual, a instalação do Oracle Linux está concluída 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 ele implanta e qualquer outra informação de implantação necessária durante a execução do laboratório.

Gravar o Playbook de Configuração Inicial

Muitos playbooks aproveitam variáveis e arquivos variáveis contendo pares de chave-valor, permitindo que as tarefas reais do playbook sejam dinâmicas enquanto o código permanece estático. Um playbook inclui as variáveis durante o tempo de execução, onde seus valores se tornam parte das execuções ao executar tarefas.

O Oracle Linux Automation Engine permite definir essas variáveis em vários locais, cada um com uma ordem de precedência. As variáveis no nível do Playbook são definidas no playbook usando a diretiva vars ou vars_files. A diretiva vars especifica as variáveis como parte da reprodução, enquanto a diretiva vars_files inclui um arquivo externo contendo as variáveis. Os desenvolvedores podem criar essas variáveis de forma dinâmica ou estática a partir de outra jogada, como faremos neste exemplo, que define a configuração do sistema antes de executar o playbook.

Abra um novo terminal e conecte via SSH ao sistema ol-control-node.
```
ssh oracle@<ip_address_of_instance>
```
Verifique se o comando do Oracle Linux Automation Engine está disponível.
```
ansible --version
```
Crie um diretório de projeto de trabalho.
```
mkdir -p ~/ol-playbook
```

Crie um diretório e um arquivo variável para o projeto.

mkdir ~/ol-playbook/vars

touch ~/ol-playbook/vars/defaults.yml

Adicione as variáveis e os valores ao arquivo.
```
   
cat << EOF | tee ~/ol-playbook/vars/defaults.yml > /dev/null
---
username: oracle
user_default_password: oracle
ssh_key_file: id_rsa
ssh_private_key_file: "{{ lookup('file', lookup('env','HOME') + '/.ssh/' + ssh_key_file + '.pub') }}"
additional_packages: ['git']
EOF
   
```
Essas informações explicam cada variável e como ela será usada:
- username: O nome do usuário sudo criado ao executar o playbook. Para este exemplo, o nome do usuário será oracle.
- user_default_password: A senha padrão do usuário oracle quando criada. A senha é necessária ao executar comandos sudo.
- ssh_key_file: Define o nome do par de chaves SSH do usuário.
- ssh_private_key_file: Copia a chave pública SSH do usuário para o arquivo authorized_key do usuário remoto no caminho fornecido. O exemplo usa o plug-in lookup para localizar a chave pública id_rsa.pub no diretório $HOME/.ssh/ de usuários locais.
- additional_packages: Adicione o nome de quaisquer pacotes adicionais a serem instalados no formato de array. Cada pacote da matriz deve estar entre aspas simples e separado por vírgula. Se você instalar um módulo appstream, como container-tools, o array será semelhante a ['git',' @container-tools:ol8'].

Crie o arquivo de playbook.

   
cat << EOF | tee ~/ol-playbook/setup.yml > /dev/null
---
- hosts: all
  become: yes
  vars_files:
    - vars/defaults.yml

  tasks:

  - name: Generate new ssh keypair
    community.crypto.openssh_keypair:
      path: "~/.ssh/{{ ssh_key_file }}"
      size: 2048
      comment: olam ssh keypair
    become: true
    become_user: "{{ username }}"
    delegate_to: localhost

  - name: Add a user account with access to sudo
    ansible.builtin.user:
      name: "{{ username }}"
      password: "{{ user_default_password | password_hash('sha512') }}"
      comment: Default Oracle user
      groups: wheel
      append: yes
      update_password: on_create

  - name: Set the authorized key for the user using a local public key file
    ansible.posix.authorized_key:
      user: "{{ username }}"
      state: present
      key: "{{ ssh_private_key_file }}"

  - name: install additional packages
    ansible.builtin.dnf:
      name: "{{ additional_packages }}"
      state: latest
EOF
   

As tarefas específicas de um manual e os nomes dos módulos visam tornar a documentação automática do manual. Esses itens instruem onde e quem executa as peças:

hosts: all: Esta linha especifica quais hosts do inventário executarão as tarefas.
become: yes: Instrui as tarefas dentro desta seção a serem executadas com o privilégio sudo por padrão.
vars_files" Esta diretiva carrega o arquivo de variáveis que contém a configuração do playbook deste tutorial.

Instalar as Coleções Obrigatórias

O pacote ansible-core contém um conjunto mínimo de módulos para gerenciar hosts chamados de coleção ansible.builtin. Coleção é um método para distribuir playbooks, atribuições, módulos ou plug-ins que executam uma tarefa direcionada. O ansible-core requer o download e a instalação de todos os módulos ou coleções necessários fora dos builtins.

Como o manual acima usa a coleção ansible.posix, precisamos instalar essa coleção e outras. A maneira mais fácil de fazer isso é criando um arquivo de requisitos que contém todas as dependências.

Crie um arquivo de requisitos.

cat << 'EOF' | tee ~/ol-playbook/requirements.yml > /dev/null
---
collections:
  - name: ansible.posix
  - name: community.crypto
EOF

Instale a coleção.
```
ansible-galaxy collection install -r ~/ol-playbook/requirements.yml
```
A saída mostra o processo de recuperar o arquivo compactado do site Galaxy e, em seguida, instalá-lo em seu diretório home em .ansible/collections.
Observação: Se a saída mostrar ERROR: Ansible requires the locale encoding to be UTF-8; Detected None., isso indicará uma definição de configuração regional incorreta para ansible. Corrija o problema definindo estas duas variáveis de ambiente:
```
export LC_ALL="en_US.UTF-8"
export LC_CTYPE="en_US.UTF-8"
```

Executar o Playbook

Antes de executar o playbook, devemos criar um arquivo de inventário para este projeto que aponte para a instância remota do Oracle Linux que planejamos gerenciar.

Atribua o endereço IP do ol-host a uma variável do nosso sistema remoto.

Essa variável facilita a criação do script do arquivo de inventário.
```
export REMOTE=<ip_address_of_instance>
```

Crie um novo diretório de projeto do arquivo de inventário.

cat << EOF | tee ~/ol-playbook/inventory > /dev/null
[production]
ol-host ansible_host=$REMOTE
EOF

Altere para o diretório de trabalho do projeto.
```
cd ~/ol-playbook
```
Teste a conexão com o comando ad hoc ping.
```
ansible ol-host -i ~/ol-playbook/inventory -m ping -u opc
```
- -u: Passa o nome do usuário para a conexão ssh. No ambiente de laboratório gratuito, usamos o usuário opc, o usuário padrão fornecido nas instâncias do Oracle Linux na Oracle Cloud Infrastructure (OCI). Aprove a impressão digital da chave ECDSA digitando yes no prompt para continuar.
O comando é executado com êxito com resultados semelhantes aos mostrados.
Exemplo de saída:
```
ol-host | SUCCESS => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/bin/python"
    },
    "changed": false,
    "ping": "pong"
}
```
Execute o playbook.
```
ansible-playbook -i inventory setup.yml -u opc
```
O comando deve ser executado com êxito, mostrando o resultado alterado de cada execução.

Conectar ao Host Remoto

Se o playbook for executado com sucesso, poderemos nos conectar ao sistema remoto com o usuário, conforme definido na variável nome de usuário.

Conecte via SSH ao sistema ol-host.
```
ssh oracle@$REMOTE
```
Se você alterou o valor da variável ssh_key_file, precisará passar a opção `-i' para ssh, apontando para o arquivo de chave privada do par especificado.
Exemplo:
```
ssh -i ~/.ssh/<local_ssh_private_key> <username>@<ip_address_of_host>
```
Verifique a instalação dos pacotes solicitados.

Depois de fazer log-in, você pode verificar se o playbook instalou o pacote git.
```
git --version
```
Desconecte do host remoto.
```
exit
```

Adicionar um Repositório

O Oracle Linux fornece uma plataforma segura, escalável e confiável onde você pode implementar seus aplicativos de missão crítica. A adição de um repositório extra é usada para instalar um novo produto Oracle ou um aplicativo de terceiros. O Oracle Linux fornece pacotes complementares que tratam do provisionamento desses repositórios adicionais.

O servidor YUM do Oracle Linux fornece detalhes dos muitos repositórios diferentes que a Oracle fornece.

Adicione essas tarefas adicionais ao arquivo de playbook existente.
```
cat << EOF | tee -a setup.yml > /dev/null
  - name: Add the EPEL repository
    ansible.builtin.dnf:
      name: oracle-epel-release-el8
      state: present
    when:
      - ansible_distribution == 'OracleLinux'
      - ansible_facts['distribution_major_version'] == '8'

  - name: Install the htop utility package
    ansible.builtin.dnf:
      name: htop
      enablerepo: ol8_developer_EPEL
      state: present
    when:
      - ansible_distribution == 'OracleLinux'
      - ansible_facts['distribution_major_version'] == '8'
EOF
```
Este manual adiciona duas tarefas dentro do jogo definido. A primeira adiciona o repositório EPEL aos repositórios de software existentes na instância do Oracle Linux. Enquanto isso, a segunda execução instala o pacote htop na mesma instância de host de destino.

Parâmetros que merecem atenção:
- state: present: Garante que o pacote referenciado já esteja no sistema ou seja instalado usando dnf.
- enablerepo: Ativa o repositório específico (se desativado) somente durante a tarefa atual.
Execute novamente o manual para executar as tarefas adicionais.
```
ansible-playbook -i inventory setup.yml -u opc
```
O playbook termina com sucesso, mostrando alguns avisos que podemos ignorar. O playbook reporta tarefas concluídas corretamente com um status ok ou alterado. O status alterado indica que o playbook modificou o host adicionando o pacote htop ou atualizando o cache dnf ao solicitar a versão mais recente de um pacote, em vez de apenas verificar se ele está presente. Um ok indica a conclusão da tarefa e não requer ação.
Verifique a instalação do repositório e do pacote.
```
ssh oracle@$REMOTE which htop
```
Execute o comando htop.
```
ssh oracle@$REMOTE -t htop
```
A opção -t do comando SSH força uma alocação TTY pois htop requer um shell interativo.
Saia do programa htop digitando q.

Adicionar, Atualizar e Excluir Arquivos e Diretórios

Crie um diretório e um arquivo adicionando o seguinte ao arquivo de playbook existente.
```
   
cat << EOF | tee -a setup.yml > /dev/null     

  - name: Create an example directory (if it does not already exist)
    ansible.builtin.file:
      path: "/home/{{ username }}/example"
      state: directory
      mode: '0755'
    become_user: "{{ username }}"

  - name: Create an empty file
    ansible.builtin.file:
      path: "/home/{{ username }}/example/test.txt"
      state: touch
      # mode: u=rw,g=r,o=r
    become_user: "{{ username }}"
EOF
   
```
Este manual adiciona duas tarefas dentro do jogo definido. O primeiro cria um novo diretório chamado exemplo no diretório inicial do usuário remoto, e o segundo cria um arquivo vazio chamado test.txt no diretório exemplo recém-criado.

Parâmetros adicionais dignos de nota:
- state:: O módulo ansible.builtin.file suporta os seguintes parâmetros: ausente, diretório, arquivo, hard, link e touch. Essas tarefas usam diretório, que cria o caminho do diretório, se ainda não estiver presente, e touch, que cria um arquivo vazio, se ainda não estiver presente.
- mode: Define as permissões do sistema de arquivos para o objeto criado. Ao usar a linha de comando, você pode usar os modos octal 0644 ou simbólico u=rw,g=r,o=r. O modo padrão do sistema será aplicado se você omitir o parâmetro mode:.
- become_user: "": Usa a funcionalidade de escalonamento de privilégios do Oracle Linux Automation Engine para executar uma tarefa. Em tutoriais anteriores, introduzimos a funcionalidade de escalação de privilégios become: para executar uma tarefa como root. Este exemplo ilustra como usar uma funcionalidade semelhante para executar uma tarefa como outro usuário. Definimos o usuário como a variável "", que predefinimos como o usuário oracle no arquivo vars/defaults.yml. Portanto, essa tarefa é executada como o usuário oracle e herda os padrões desse usuário.
Execute o manual para executar as tarefas adicionais.
```
ansible-playbook -i inventory setup.yml -u opc
```
Confirme se o novo diretório e arquivo existe no host remoto.
```
ssh oracle@$REMOTE ls -al example
```
A saída confirma a criação de um novo diretório e o arquivo vazio. Observe que o arquivo test.txt tem zero bytes e que o usuário oracle o possui.
Adicionar vários arquivos.

Durante a configuração de um sistema, pode ser necessário criar vários arquivos dentro de um diretório. Em vez de usar tarefas individuais, você pode criar vários arquivos em um diretório como uma operação atômica.
```
   
cat << EOF | tee -a setup.yml > /dev/null     

  - name: Add multiple files
    ansible.builtin.file:
      path: "/home/{{ username }}/example/{{ item }}"
      state: touch
    with_items:
    - file01.txt
    - file02.txt
    - file03.txt
    - file04.txt
    become_user: "{{ username }}"
EOF
   
```
Esta tarefa usa um loop para criar vários arquivos vazios de uma lista.
- path:: Define o local no sistema remoto para gravar os arquivos. O Oracle Linux Automation Engine substitui a variável `` por cada item do parâmetro with_items durante o runtime.
- with_items:: Este parâmetro indica a lista de items a serem submetidos a loop durante a execução desta tarefa. Embora este exemplo use apenas quatro nomes de arquivo, você pode fazer a lista o tempo necessário.
Execute o manual para executar as tarefas adicionais.
```
ansible-playbook -i inventory setup.yml -u opc
```
Confirme se o novo diretório e arquivo existe no host remoto.
```
ssh oracle@$REMOTE ls -al example
```
A saída exibe o arquivo test.txt original e os novos.

Adicione uma única linha de conteúdo a um arquivo.

   
cat << 'EOF' | tee -a setup.yml > /dev/null     

  - name: Insert some text into the test.txt file
    ansible.builtin.lineinfile:
      path: "/home/{{ username }}/example/test.txt"
      line: This is a test
      create: True
      owner: "{{ username }}"
      group: "{{ username }}"
      mode: '0644'

  - name: Add an extra line after the line just inserted
    ansible.builtin.lineinfile:
      path: "/home/{{ username }}/example/test.txt"
      regexp: '^a test'
      insertafter: 'This is a test'
      line: This is some updated text that was added later.
      create: True
      owner: "{{ username }}"
      group: "{{ username }}"
      mode: '0644'

  - name: Get the contents of the test.txt file
    ansible.builtin.command: cat ~/example/test.txt
    register: command_output
    become_user: "{{ username }}"

  - name: Print the results of the cat command
    ansible.builtin.debug:
      msg: "{{ command_output }}"

  - name: Print only the lines added to the text file
    ansible.builtin.debug:
      msg: "{{ command_output.stdout_lines }}"
EOF
   

As duas primeiras tarefas usam o ansible.builtin.lineinfile para adicionar e atualizar linhas únicas no arquivo.
As tarefas restantes mostram um método para confirmar as alterações. O playbook primeiro usa o ansible.builtin.command para gerar o conteúdo do arquivo atualizado para stdout e salva-o na memória em uma variável register. Em seguida, ele usa o módulo ansible.builtin.debug para imprimir esse conteúdo na tela como parte da saída do playbook. A segunda tarefa de depuração mostra uma maneira de limitar a saída a apenas uma parte específica da saída JSON da tarefa anterior.

Execute o manual para executar as tarefas adicionais.
```
ansible-playbook -i inventory setup.yml -u opc
```
A última tarefa no playbook imprime o conteúdo do arquivo usando o módulo debug.

Adicionar várias linhas de conteúdo a um arquivo.

   
cat << EOF | tee -a setup.yml > /dev/null     

  - name: Add two lines into test.txt
    ansible.builtin.blockinfile:
      path: "/home/{{ username }}/example/test.txt"
      insertafter: 'This is some updated text that was added later.'
      block: |
        "Welcome to {{ ansible_hostname }}"
        "Last updated on {{ ansible_date_time.iso8601 }}"

  - name: Create a new file and insert content into it
    ansible.builtin.copy:
      content: |
        === The text below was added by Oracle Linux Automation Engine ==========

        Hello from the ansible.builtin.copy module.
        This task is an example of inserting multiple lines into a text file.
        You can insert more lines if you want.

        === The text above was added by Oracle Linux Automation Engine ===========
      dest: "/home/{{ username }}/example/testing.txt"
      mode: '0644'
    become_user: "{{ username }}"
EOF
   

Execute o manual para executar as tarefas adicionais.
```
ansible-playbook -i inventory setup.yml -u opc
```
Confirme se duas novas linhas estão presentes no arquivo.
```
ssh oracle@$REMOTE cat example/test.txt
```
A saída mostra o conteúdo adicionado e interpreta os valores de variável da tarefa com base na coleta automática de fatos feita pelo playbook em relação ao host remoto durante o runtime.
Confirme a criação do novo arquivo e a adição do conteúdo.
```
ssh oracle@$REMOTE cat example/testing.txt
```
Excluir arquivos e diretórios.

Além de criar arquivos e diretórios e adicionar texto, o Oracle Linux Automation Engine também pode excluir esses itens. Vamos remover o diretório e todos os arquivos que este playbook cria e deixar o sistema no mesmo estado de quando começamos. Essas tarefas primeiro usam o parâmetro state: definido como ausente para remover a lista de arquivos e, em seguida, o diretório. A segunda tarefa lida com a remoção dos arquivos em uma única etapa junto com o diretório. Ainda assim, incluímos a primeira tarefa para demonstração adicional dos recursos do Oracle Linux Automation Engine.
```
    
cat << EOF | tee -a setup.yml > /dev/null     

  - name: Delete multiple files
    ansible.builtin.file:
      path: '{{ item }}'
      state: absent
    with_items:
      - "/home/{{ username }}/example/test.txt"
      - "/home/{{ username }}/example/file01.txt"
      - "/home/{{ username }}/example/file02.txt"
      - "/home/{{ username }}/example/file03.txt"
      - "/home/{{ username }}/example/file04.txt"
      - "/home/{{ username }}/example/testing.txt"

  - name: Recursively remove directory
    ansible.builtin.file:
      path: "/home/{{ username }}/example"
      state: absent
EOF
    
```
É possível excluir recursivamente um diretório e qualquer conteúdo usando a segunda tarefa mostrada. A primeira tarefa, excluir os arquivos individualmente, está presente caso você queira apenas excluir arquivos. Se você quiser excluir arquivos e arquivos e diretórios, a segunda tarefa será mais eficiente.
Execute o manual para executar as tarefas adicionais.
```
ansible-playbook -i inventory setup.yml -u opc
```
Verifique a remoção do diretório especificado.
```
ssh oracle@$REMOTE ls
```
A falta de saída confirma o diretório especificado e os arquivos criados durante este tutorial desapareceram.

Próximas Etapas

Parabéns por ter chegado até aqui. Este tutorial apresentou várias maneiras de o Oracle Linux Automation Engine tornar possível a execução de tarefas rotineiras no Oracle Linux por meio da automação, como instalar pacotes, criar, atualizar e excluir arquivos e diretórios e adicionar contas de usuário ao Oracle Linux. Também mostramos como usar o módulo ansible.builtin.debug do Oracle Linux Automation Engine para retornar informações ao terminal durante a execução de um Playbook. Com essas habilidades, você tem uma vantagem inicial para se aventurar e escrever seus próprios playbooks.

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.

Título e Informações de Copyright

Run Oracle Linux Tasks with Oracle Linux Automation Engine

F49863-05