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"
olam_type: olae
EOF

Crie um arquivo de inventário.

cat << EOF | tee hosts > /dev/null
localhost ansible_connection=local ansible_connection=local ansible_python_interpreter=/usr/bin/python3.6
EOF

Implante o ambiente de laboratório.
```
ansible-playbook create_instance.yml -i hosts -e "@instances.yml"
```
O ambiente de laboratório gratuito requer a variável extra ansible_python_interpreter para localhost porque instala o pacote RPM para o Oracle Cloud Infrastructure SDK para Python. O local para instalar este pacote está nos módulos Python padrão do sistema com base na sua versão do Oracle Linux. Usar uma variável de inventário evita impactar as reproduções em execução em hosts diferentes de localhost.

A forma de implantação padrão usa a CPU AMD. Você pode alterar a forma das instâncias especificando uma nova definição de variável de forma na linha de comando.

Por exemplo: -e instance_shape="VM.Standard3.Flex"

Da mesma forma, a versão padrão da imagem do Oracle Linux usa a variável os_version definida no arquivo `default_vars.yml. Você pode modificar esse valor especificando a versão principal do Oracle Linux na linha de comando.

Por exemplo: -e os_version="9"

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

Gravar o Playbook de Configuração Inicial

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

O Oracle Linux Automation Engine permite definir essas variáveis em vários locais, cada um com uma ordem específica 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 dinamicamente ou estaticamente a partir de outro jogo, como faremos neste exemplo, que define a configuração do sistema antes de executar o playbook.

Abra um novo terminal e conecte-se ao sistema ol-control-node via SSH.
```
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, organizados na coleção ansible.builtin. Uma 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 quaisquer módulos ou coleções necessários fora dos built-ins.

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 arquivo de inventário no diretório do projeto.

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, exibindo o resultado alterado de cada jogo.

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-se ao sistema ol-host via SSH.
```
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 oferece uma plataforma segura, escalável e confiável para 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 sobre os diversos repositórios que a Oracle oferece.

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: Add the EPEL repository
    ansible.builtin.dnf:
      name: oracle-epel-release-el9
      state: present
    when:
      - ansible_distribution == 'OracleLinux'
      - ansible_facts['distribution_major_version'] == '9'

  - 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'

  - name: Install the htop utility package
    ansible.builtin.dnf:
      name: htop
      enablerepo: ol9_developer_EPEL
      state: present
    when:
      - ansible_distribution == 'OracleLinux'
      - ansible_facts['distribution_major_version'] == '9'
EOF

Este playbook adiciona várias tarefas ao playbook definido. O primeiro conjunto adiciona o repositório EPEL aos repositórios de software existentes na instância do Oracle Linux. Enquanto isso, o segundo conjunto de reproduções instala o pacote htop na mesma instância do 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 é concluído com sucesso, exibindo alguns avisos durante a execução. Você pode desconsiderar esses avisos por enquanto, pois eles não afetam o manual atual. O manual reporta as tarefas como concluídas adequadamente 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. Estas tarefas utilizam 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 usuário root. Este exemplo ilustra como usar 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 do sistema, pode ser necessário criar vários arquivos em um diretório. Ao invés de usar tarefas individuais, você pode criar vários arquivos em um diretório como uma única 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 ser percorrida durante a execução desta tarefa. Embora este exemplo use apenas quatro nomes de arquivo, você pode criar a lista, desde que 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 an additional test.
      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 o salva 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 demonstra um método para limitar a saída a 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.
Confirmar a criação do novo ficheiro e a adição do nosso 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, deixando o sistema no mesmo estado que quando começamos. Essas tarefas primeiro usam o parâmetro state: definido como absent para remover a lista de arquivos e, em seguida, o diretório. A segunda tarefa trata da remoção dos arquivos e do diretório em uma única etapa. 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, excluindo arquivos individualmente, está disponível se você quiser excluir apenas arquivos específicos. Se você deseja excluir arquivos e arquivos e diretórios, a segunda tarefa é 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 que o diretório especificado e os arquivos criados durante este tutorial não estão mais presentes.

Próximas Etapas

Parabéns por chegar até aqui. Este tutorial introduziu várias maneiras pelas quais o Oracle Linux Automation Engine permite a automação de tarefas de rotina no Oracle Linux, incluindo a instalação de pacotes, criação, atualização e exclusão de arquivos e diretórios, bem como a adição de contas de usuário ao Oracle Linux. Também demonstramos como utilizar o módulo ansible.builtin.debug do Oracle Linux Automation Engine para exibir informações no terminal durante a execução de um Playbook. Com essas habilidades, você tem uma vantagem para se aventurar e escrever seus 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-06