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, o software de código aberto para provisionamento e gerenciamento de configuração, usa um arquivo de inventário para trabalhar em nós gerenciados ou hosts em 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 ótimo ter uma maneira de ter seu inventário atualizado dinamicamente à medida que os hosts vêm e vão.

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"
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.

Instalar Nó de Controle do Oracle Linux Automation Engine

O nó de controle é o sistema no qual os playbooks do Oracle Linux Automation Engine são executados. Antes de executar playbooks, é necessário instalar os pacotes do Oracle Linux Automation Engine.

Abra um novo terminal e conecte via SSH ao sistema ol-control-node.
```
ssh oracle@<ip_address_of_instance>
```
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 ol8_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"
```

Configurar 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.
```
sudo dnf install -y python3.12-pip python3.12-setuptools
```
2. Instalar os pacotes Python
```
/usr/bin/python3.12 -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.
```
python3.12 -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 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 da área de trabalho, devemos modificar a parte do diretório home do usuário do key_file.
```
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
```
python3.12 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 Coleta do OCI Ansible contém um conjunto de módulos para automatizar o provisionamento e a configuração da infraestrutura de nuvem, a orquestração de processos operacionais complexos e a implantação e atualização de seus 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
```
O fetch_compute_hosts definido como true resulta no inventário coletando apenas informações sobre hosts de computação e ignorando 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 priorizará o endereço IP privado de um sistema em relação ao 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 de inventário dinâmico e configurado, podemos usá-lo para executar um manual simples. Certifique-se de ativar o acesso SSH entre seus nós de controle e todos os controles remotos. Configuramos isso usando log-ins SSH sem senha durante a implantação inicial das instâncias.

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