Neste post, aprendemos como usar o plug-in Kubernetes na ferramenta Ansible. No Ansible, é difícil gerenciar um grande número de contêineres. Mas utilizar o Kubernetes no Ansible é útil ao gerenciar os contêineres. Neste guia, aprenderemos o que é a fonte de inventário do Kubernetes e como ela funciona no Ansible.
O Google lançou o software de gerenciamento de fácil acesso chamado Kubernetes, também conhecido como K8s, usado para gerenciar as configurações virtualizadas em um conjunto remoto de máquinas com recursos de instalação sem tempo de inatividade, reversão automatizada e escalabilidade que fornece ao plug-in Kubernetes uma capacidade extremamente adaptável arquitetura em Ansible. Por meio da disponibilidade de APIs REST para a funcionalidade necessária, o objetivo principal do Kubernetes é ocultar as complexidades associadas ao controle de vários contêineres.
A configuração do Kubernetes é baseada em cliente-servidor. No entanto, por padrão, há apenas um servidor principal que atua como host de controle. No Kubernetes, também podemos usar controladores multiprincipais para a configuração do Kubernetes. A fonte de inventário K8s é ocasionalmente necessária para controlar sistemas e configurar os serviços no host remoto para controlar pods. Mas há dificuldades em obter instruções específicas sobre como fazê-lo. Como resultado, implementamos este tutorial sobre como fazer um Ansible Playbook que extrai os pods em um domínio e produz uma fonte de inventário Kubernetes.
Pré-requisitos para usar a fonte de inventário do Kubernetes no Ansible
Para usar a fonte de inventário Kubernetes no Ansible, existem instruções ou comandos de processo de estágio ao longo deste guia. Certifique-se de ter a preparação necessária se quiser avançar nele:
- Para trabalhar em um cenário Ansible, primeiro configuramos a ferramenta Ansible no servidor e verificamos se você possui a versão Ansible 2.11.7 para que possamos usar facilmente o plug-in Kubernetes.
- Para avaliar o plug-in Kubernetes, precisamos de um dispositivo de servidor remoto com um cluster Kubernetes integrado.
- O host remoto está atualmente configurado para executar as instruções e playbooks do Ansible, bem como um arquivo de inventário criado. O nome do dispositivo remoto de destino é K8s Master Node.
- A versão do Python é 3.6 ou superior, que deve ser instalada no dispositivo do controlador Ansible. Ele também pode estar no dispositivo host remoto de destino.
- A versão do módulo openshift do Python é 0.6 ou superior. Também precisamos de um módulo pyYAML da versão 3.11 ou superior. Ambos os módulos devem ser configurados no dispositivo do servidor remoto, bem como no dispositivo do controlador.
Exemplo:
Aqui está o primeiro exemplo em que implementamos o Kubernetes no Ansible. Para isso, usamos qualquer ambiente Ansible para implementar a fonte de inventário Kubernetes. Os processos listados a seguir são executados no seguinte cenário usando o Kubernetes Inventory Plugin:
- Implementação do novo namespace no cluster K8s no Ansible.
- Criação do pod nginx usando o playbook Ansible.
- Criação de implantação nginx no Ansible.
Para tornar os conceitos e a execução simples de entender, implementamos o exemplo em várias etapas.
Etapa 1: implementar o novo namespace no cluster K8s no Ansible
Na primeira etapa, criamos o playbook para que possamos escrever o conteúdo no formato “.yml” no Ansible. Para criar o playbook, o seguinte é o comando que usamos:
[ raiz @ mestre ansible ] # nano nginx_pod.yml
Agora, o playbook “pod.yml” é criado e lançado no novo terminal do Ansible. Começamos a escrever o roteiro. No playbook, primeiro definimos a versão da API que usamos no pod Ansible, que é “v1”. O namespace que definimos é “ansible-namespace”. Em seguida, listamos os metadados do ansible-namespace. Nos metadados, usamos o software nginx e o rótulo que contém um frontend de camada de valor. Na especificação do playbook, listamos o nome e a imagem que está armazenada no container; ambos contêm o nginx nele.
Etapa 2: criar o documento manifesto no Ansible
Agora, criamos outro documento no mesmo diretório do Ansible que é o documento de implantação no formato “.yml”. Para criar o documento de manifesto, use o seguinte comando no terminal Ansible:
[ raiz @ mestre ansible ] # nano nginx_deployment.yml
No documento de manifesto, primeiro definimos novamente a versão do aplicativo que é “app/v1”. Então, dizemos que tipo de arquivo é, se é um arquivo de implantação. Em seguida, definimos o namespace que é ansible-namespace. Para construir a implementação, duas réplicas dentro do ansible-namespace mostram o número do pod. As imagens nginx são 1.14.2 que são lançadas no pod. O parâmetro matchLabels fornece as tags para os pods e suas especificações no parâmetro spec. Se de alguma forma as tags nos pods corresponderem às especificadas nas informações de configuração, a implementação acontece no documento de manifesto no Ansible.
Etapa 3: criar o manual para implementação do Kubernetes no Ansible
Agora, queremos criar outro playbook no Ansible. Neste playbook, implementamos a funcionalidade do Kubernetes nele. Use o seguinte comando para criar o playbook:
[ raiz @ mestre ansible ] # nano kubernetes_main.yml
O playbook é criado no mesmo diretório onde o playbook anterior e o documento de manifesto são armazenados no Ansible. No playbook, primeiro definimos a funcionalidade do playbook que queremos implementar. Para construir a conexão, fornecemos os hosts remotos que queremos atingir. Aqui, visamos “todos” os hosts. Em seguida, definimos a variável para verificar o interpretador Python no Ansible usando o caminho onde ela está armazenada. Agora, definimos as tarefas no playbook. Primeiro, verificamos o status do dispositivo minikube. Em seguida, criamos um novo namespace do Kubernetes no playbook. Em seguida, duplique o nginx_pod.yml e o nginx_deployment .yml para o dispositivo remoto.
Por meio desses documentos yml, construímos a implementação do pod no dispositivo remoto. Em seguida, verificamos se o pod Kubernetes está presente ou não no local especificado no dispositivo remoto.
Após o encerramento do playbook, agora construímos o arquivo de inventário para fazer a conexão entre o controlador Ansible e o host remoto de destino.
Todos:anfitriões:
k8s_Master_Node:
ansible_host: 192.168.3.229
ansible_user: ansible
ansible_password: ********
ansible_connection: ssh
ansible_port: 22
[ raiz @ mestre ansible ] # ansible-playbook kubernates_main.yml
Aqui está a saída desejada onde vemos que as tarefas foram colocadas com sucesso na máquina de destino:
Depois que a tarefa é colocada na máquina de destino, verificamos se o “ansible-namespace” está no cluster do Kubernetes ou não. Usamos o seguinte comando “grep”:
[ raiz @ mestre ansible ] # kubectl obter namespace | grep ansible-namespace
Se você deseja verificar o pod criado no namespace do cluster Kubernetes, escreva o seguinte comando para verificar:
[ raiz @ mestre ansible ] # kubectl get pods --namespace ansible-namespace
Como você vê na saída anterior, obtemos os pods que estão em execução no dispositivo. Agora, verificamos a implantação que fizemos no cluster Kubernetes. Utilize a seguinte instrução para verificar as implantações já feitas:
[ raiz @ mestre ansible ] # kubectl obter implantações --namespace ansible-namespace
Conclusão
Aprendemos o que é a fonte de inventário do Kubernetes no Ansible. Também aprendemos como utilizar o inventário do Kubernetes no Ansible. Em seguida, implementamos um exemplo para que possamos aprender mais claramente sobre o funcionamento da fonte de inventário do Kubernetes no Ansible.