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.

Use um Inventário Dinâmico da OCI com o Oracle Linux Automation Engine

Introdução

O Oracle Linux Automation Engine, um software de código aberto para provisionamento e gerenciamento de configuração, utiliza um arquivo de inventário para operar em nós gerenciados ou hosts dentro da sua infraestrutura. Esse arquivo de inventário contém uma lista de servidores, seus endereços IP e outras informações de conexão opcionais.

Um arquivo de inventário estático funciona bem se sua infraestrutura dificilmente mudar.

No entanto, sua infraestrutura provavelmente está em constante fluxo ao usar a nuvem. Portanto, seria benéfico ter seu inventário atualizado dinamicamente à medida que os hosts são adicionados e removidos.

Objetivos

Neste tutorial, você aprenderá a:

Configurar o Oracle Linux Automation Engine
Crie um inventário dinâmico do OCI
Use o inventário dinâmico da OCI com um manual

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: none
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.

Configurar Nó de Controle do Oracle Linux Automation Engine

O nó de controle é o sistema para executar os playbooks do Oracle Linux Automation Engine. A execução de playbooks requer a instalação do pacote Oracle Linux Automation Engine.

Defina uma variável igual ao endereço IP do nó de controle.
```
export CONTROL="<ip_address_of_ol-control-node>"
```
Abra um terminal e copie o par de chaves SSH para o nó de controle.
```
scp -rp ~/.ssh/id_rsa* oracle@$CONTROL:~/.ssh/
```

Defina as permissões na chave privada SSH.

ssh oracle@$CONTROL "chmod 600 ~/.ssh/id_rsa"

Conecte-se ao sistema ol-control-node via SSH.
```
ssh oracle@$CONTROL
```
Instale o pacote e as dependências do Oracle Linux Automation Engine.
```
sudo dnf install -y ansible-core
```
O pacote ansible-core está disponível no repositório AppStream.
Teste a instalação do pacote.
```
ansible --version
```
Revise a saída e procure a versão padrão do Python Oracle Linux Automation Manager. Esse é o ambiente em que devemos instalar o Oracle Cloud Infrastructure (OCI) SDK para Python.
Observação: Se a saída mostrar ERRO: o Ansible exige que a codificação da configuração regional seja UTF-8; Nenhuma Detectada., isso indica 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"
```

Instalar o Oracle Cloud Infrastructure SDK para Python

O plug-in do OCI Dynamic Inventory requer uma configuração do OCI SDK para Python funcional no nó de controle. Podemos instalar o OCI SDK usando o Oracle Linux RPM ou PIP, o instalador de pacotes para Python.

Instale o OCI SDK para Python usando PIP.
1. Instale os pacotes e dependências do PIP.
  
  Oracle Linux 8:
```
sudo dnf install -y python3.12-pip python3.12-setuptools
```
  Oracle Linux 9:
```
sudo dnf install -y python3.9-pip python3.9-setuptools
```
2. Instalar os pacotes Python
  
  Oracle Linux 8:
```
/usr/bin/python3.12 -m pip install oci
```
  Oracle Linux 9:
```
/usr/bin/python3.9 -m pip install oci
```
  Adicione a opção --proxy se estiver atrás de um proxy. Os detalhes estão disponíveis na ajuda executando o comando python3.12 -m pip help install.

Teste a instalação do OCI SDK para Python imprimindo sua versão.

Oracle Linux 8:

python3.12 -c "import oci;print(oci.__version__)"

Oracle Linux 9:

python3.9 -c "import oci;print(oci.__version__)"

Crie o diretório de configuração padrão do OCI SDK.
```
mkdir -p ~/.oci
```
Criar o arquivo de configuração padrão do SDK

O laboratório gratuito fornece uma configuração de SDK pré-gerada, que podemos copiar para o sistema ol-control-node usando scp.
1. Abra um terminal new a partir do ambiente de área de trabalho.
2. Copie todos os arquivos de configuração do SDK para o sistema ol-control-node.
```
scp ~/.oci/* oracle@<ip_address_of_instance>:~/.oci/.
```
```
exit
```
Se você estiver seguindo este tutorial fora do ambiente de laboratório gratuito, consulte as instruções fornecidas nas seções Arquivo de Configuração do SDK e da CLI e Chaves e OCIDs Necessários da Documentação do OCI para gerar seu arquivo de configuração do OCI.
Alterne para a janela do terminal conectada ao sistema ol-control-node.
Atualize o local do key_file no arquivo de configuração do SDK.

Ao copiar o arquivo de configuração do SDK do ambiente de área de trabalho, devemos modificar a parte do diretório home do usuário do key_file para garantir que ele corresponda ao nome do usuário do sistema de controle.
```
sed -i 's/luna.user/oracle/g' ~/.oci/config
```

Crie um script Python de teste para verificar se o SDK está funcionando.

cat << EOF | tee test.py > /dev/null
import oci
object_storage_client = oci.object_storage.ObjectStorageClient(oci.config.from_file())
result = object_storage_client.get_namespace()
print("Current object storage namespace: {}".format(result.data))
EOF

O script test.py exibe o namespace do serviço Object Storage para a Tenancy e o Compartimento do OCI configurados.

Execute o script

Oracle Linux 8:
```
python3.12 test.py
```
Oracle Linux 9:
```
python3.9 test.py
```
O script de teste imprime com sucesso o namespace exclusivo da tenancy configurada.

Instalar a Coleção do Ansible do Oracle Cloud Infrastructure

A Coleção do OCI Ansible contém um conjunto de módulos que automatizam o provisionamento e a configuração da infraestrutura de nuvem, orquestram processos operacionais complexos e implementam e atualizam ativos de software.

Crie um diretório de projeto.
```
mkdir ~/myproject
```

Crie um arquivo de requisitos.

cat << EOF | tee ~/myproject/requirements.yml > /dev/null
---
collections:
  - name: oracle.oci
EOF

Instalar a Coleção do OCI Ansible.
```
ansible-galaxy collection install -r ~/myproject/requirements.yml
```
Se você instalou uma versão anterior, obtenha a versão mais recente executando o comando com a opção --force.
```
ansible-galaxy collection install --force oracle.oci
```

Como Trabalhar com o OCI Dynamic Inventory

A Oracle inclui seu plug-in de inventário dinâmico na Coleção Ansible do OCI.

Configure o plug-in de inventário criando uma origem de configuração YAML.

O nome do arquivo de origem precisa ser <filename>.oci.yml ou <filename>.oci.yaml. Em que <filename> é um identificador útil definido pelo usuário.
```
cat << EOF | tee ~/myproject/myproject.oci.yml > /dev/null
---
plugin: oracle.oci.oci

# Optional fields to specify oci connection config:
config_file: ~/.oci/config
config_profile: DEFAULT
EOF
```
Teste o plug-in de inventário criando um gráfico de inventário.
```
ansible-inventory -i ~/myproject/myproject.oci.yml --graph
```
A saída mostra uma série de avisos e erros. Então, o que deu errado?

O erro ocorre porque o plug-in requer saber o OCID do compartimento. Se você fornecer o OCID da tenancy em vez do OCID do compartimento e tiver as permissões corretas, o plug-in gerará um inventário para toda a tenancy.

Como o plug-in não pode ler as informações do OCID do compartimento diretamente no arquivo de configuração do SDK, adicione-o ao arquivo de origem de configuração do plug-in.
Pegue o OCID do compartimento no arquivo de configuração do SDK e designe-o à variável comp_ocid.
```
comp_ocid=$(grep -i compartment ~/.oci/config | sed -e 's/compartment-id=//g')
```
Anexe um parâmetro de compartimento ao arquivo de origem do plug-in.
```
cat << EOF | tee -a ~/myproject/myproject.oci.yml > /dev/null

compartments:
  - compartment_ocid: "$comp_ocid"
    fetch_compute_hosts: true
EOF
```
A definição de fetch_compute_hosts como true só resulta na coleta de informações de inventário em hosts de computação e na ignorância de outros tipos de instância implantados no compartimento.
Reexecutar o teste.
```
ansible-inventory -i ~/myproject/myproject.oci.yml --graph
```
Nosso exemplo mostra as instâncias de computação disponíveis no compartimento como uma listagem de grupos de inventário designados pelo caractere @ e exibe o endereço IP público da instância.

E se quiséssemos o endereço IP privado?

A captura do endereço IP privado é necessária com base na localização física do nó controlador ou na topologia de rede configurada na infraestrutura de nuvem. Outro motivo para obter o endereço IP privado é quando as instâncias de computação solicitadas só têm um endereço IP privado.
Altere o parâmetro de formato do nome do host do plug-in atualizando o arquivo de origem de configuração do plug-in.
```
cat << EOF | tee -a ~/myproject/myproject.oci.yml > /dev/null

hostname_format_preferences:
  - "private_ip"
  - "public_ip"
EOF
```
O formato de exemplo acima prioriza o endereço IP privado de um sistema sobre seu endereço IP público. Para obter mais detalhes sobre essa configuração, consulte Preferências de Formato de Nome de Host na documentação.
Teste novamente o plug-in.
```
ansible-inventory -i ~/myproject/myproject.oci.yml --graph
```
A saída agora exibe o endereço IP privado.

Executar um Playbook

Com a configuração do inventário dinâmico e configurado, podemos usá-lo para executar um playbook simples. Certifique-se de ativar o acesso SSH entre os nós de controle e quaisquer nós remotos.

Crie um playbook que faça ping no host.
```
cat << EOF | tee ~/myproject/ping.yml > /dev/null
---
- hosts: all,!$(hostname -i)
  tasks:
  - name: Ansible ping test
    ansible.builtin.ping:
EOF
```
O Oracle Linux Automation Engine espera uma lista separada por vírgulas de hosts ou grupos após a entrada - hosts:, e ! indica que deve excluir essas entradas. A entrada all fará ping de cada host mostrado no inventário como @all dentro do grupo de nível superior. Você pode modificar este playbook para usar um grupo diferente da saída do gráfico removendo o caractere @ de seu nome e informando esse nome na entrada - hosts:.
Execute o playbook.
```
ansible-playbook -u opc -i ~/myproject/myproject.oci.yml ~/myproject/ping.yml
```
Aceite a impressão digital da chave ECDSA quando solicitado.

A opção -i define o arquivo de inventário dinâmico usado.

A opção -u define o usuário SSH remoto ao tentar uma conexão.

Próximas Etapas

A conclusão da execução do playbook com um status ok confirma que o Oracle Linux Automation Engine usa com sucesso o inventário dinâmico do OCI para se comunicar com a instância remota descoberta no compartimento. Continue aprendendo e use esse recurso para ajudar a gerenciar sua frota de instâncias do OCI e executar tarefas de administração de rotina no 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.

Título e Informações de Copyright

Use an OCI Dynamic Inventory with Oracle Linux Automation Engine

F55849-03