Automatize a orquestração de contêineres com módulos Ansible para Kubernetes
Combine Ansible com Kubernetes para automação em nuvem. Além disso, obtenha nossa folha de dicas para usar o módulo Ansible k8s.
Ansible é uma das melhores ferramentas para automatizar seu trabalho. Kubernetes é uma das melhores ferramentas para orquestrar contêineres. O que acontece quando você combina os dois? Como seria de esperar, o Ansible combinado com o Kubernetes permite automatizar a orquestração do seu contêiner.
Módulos Ansible
Por si só, o Ansible é basicamente apenas uma estrutura para interpretar arquivos YAML. Seu verdadeiro poder vem de seus vários módulos. Módulos são o que permitem invocar aplicativos externos com apenas algumas configurações simples em um manual.
Existem alguns módulos que lidam diretamente com Kubernetes e alguns que lidam com tecnologias relacionadas, como Docker e Podman. Aprender um novo módulo geralmente é semelhante a aprender um novo comando de terminal ou uma nova API. Você se familiariza com um módulo a partir de sua documentação, aprende quais argumentos ele aceita e compara suas opções a como você pode usar o aplicativo com o qual ele faz interface.
Acesse um cluster Kubernetes
Para experimentar os módulos Kubernetes no Ansible, você deve ter acesso a um cluster Kubernetes. Se não tiver isso, você pode tentar abrir uma conta de teste online, mas a maioria delas é de curto prazo. Em vez disso, você pode instalar o Minikube, conforme descrito no site do Kubernetes ou no excelente artigo de Bryant Son sobre como começar a usar o Minikube. O Minikube fornece uma instância local de instalação do Kubernetes de nó único, permitindo que você configure e interaja com ele como faria com um cluster completo.
[Baixe a folha de referências do Ansible k8s]
Antes de instalar o Minikube, você deve garantir que seu ambiente esteja pronto para servir como backend de virtualização. Talvez seja necessário instalar libvirt
e conceder permissão ao grupo libvirt
:
$ sudo dnf install libvirt
$ sudo systemctl start libvirtd
$ sudo usermod --append --groups libvirt `whoami`
$ newgrp libvirt
Instale módulos Python
Para se preparar para usar módulos Ansible relacionados ao Kubernetes, você também deve instalar alguns módulos auxiliares do Python:
$ pip3.6 install kubernetes --user
$ pip3.6 install openshift --user
Inicie o Kubernetes
Se você estiver usando Minikube em vez de um cluster Kubernetes, use o comando minikube
para iniciar uma instância local e miniaturizada do Kubernetes em seu computador:
$ minikube start --driver=kvm2 --kvm-network default
Aguarde a inicialização do Minikube. Dependendo da sua conexão com a Internet, isso pode levar vários minutos.
Obtenha informações sobre seu cluster
Depois de iniciar seu cluster com sucesso, você poderá obter informações sobre ele com a opção cluster-info
:
$ kubectl cluster-info
Kubernetes master is running at https://192.168.39.190:8443
KubeDNS is running at https://192.168.39.190:8443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy
To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.
Use o módulo k8s
O ponto de entrada para usar o Kubernetes por meio do Ansible é o módulo k8s
, que permite gerenciar objetos do Kubernetes a partir de seus playbooks. Este módulo descreve estados resultantes de instruções kubectl
. Por exemplo, veja como você criaria um novo namespace com kubectl
:
$ kubectl create namespace my-namespace
É uma ação simples, e a representação YAML do mesmo resultado é igualmente concisa:
- hosts: localhost
tasks:
- name: create namespace
k8s:
name: my-namespace
api_version: v1
kind: Namespace
state: present
Nesse caso, o host é definido como localhost
, supondo que você esteja executando isso no Minikube. Observe que o módulo em uso define a sintaxe dos parâmetros disponíveis (como api_version
e kind
).
Antes de usar este manual, verifique-o com yamllint
:
$ yamllint example.yaml
Corrija quaisquer erros e execute o playbook:
$ ansible-playbook ./example.yaml
Verifique se o novo namespace foi criado:
$ kubectl get namespaces
NAME STATUS AGE
default Active 37h
kube-node-lease Active 37h
kube-public Active 37h
kube-system Active 37h
demo Active 11h
my-namespace Active 3s
Extraia uma imagem de contêiner com Podman
Contêineres são sistemas Linux, de escopo quase impossivelmente mínimo, que podem ser gerenciados pelo Kubernetes. Muitas das especificações do contêiner foram definidas pelo projeto LXC e pelo Docker. Uma adição recente ao conjunto de ferramentas de contêiner é o Podman, que é popular porque é executado sem a necessidade de um daemon.
Com o Podman, você pode extrair uma imagem de contêiner de um repositório, como Docker Hub ou Quay.io. A sintaxe do Ansible para isso é simples e tudo que você precisa saber é a localização do contêiner, que está disponível no site do repositório:
- name: pull an image
podman_image:
name: quay.io/jitesoft/nginx
Verifique com yamllint
:
$ yamllint example.yaml
E então execute o manual:
$ ansible-playbook ./example.yaml
[WARNING]: provided hosts list is empty, only localhost is available.
Note that the implicit localhost does not match 'all'
PLAY [localhost] ************************
TASK [Gathering Facts] ************************
ok: [localhost]
TASK [create k8s namespace] ************************
ok: [localhost]
TASK [pull an image] ************************
changed: [localhost]
PLAY RECAP ************************
localhost: ok=3 changed=1 unreachable=0 failed=0
skipped=0 rescued=0 ignored=0
Implantar com Ansible
Você não está limitado a pequenas tarefas de manutenção com o Ansible. Seu manual pode interagir com o Ansible da mesma forma que um arquivo de configuração faz com o kubectl
. Na verdade, de muitas maneiras, o YAML que você conhece ao usar o Kubernetes se traduz em suas jogadas Ansible. Aqui está uma configuração que você pode passar diretamente para kubectl
para implantar uma imagem (neste exemplo, um servidor web):
apiVersion: apps/v1
kind: Deployment
metadata:
name: my-webserver
spec:
selector:
matchLabels:
run: my-webserver
replicas: 1
template:
metadata:
labels:
run: my-webserver
spec:
containers:
- name: my-webserver
image: nginx
ports:
- containerPort: 80
Se você conhece esses parâmetros, então conhece principalmente os parâmetros necessários para realizar o mesmo com o Ansible. Você pode, com muito poucas modificações, mover esse YAML para um elemento definition
em seu manual do Ansible:
- name: deploy a web server
k8s:
api_version: v1
namespace: my-namespace
definition:
kind: Deployment
metadata:
labels:
app: nginx
name: nginx-deploy
spec:
replicas: 1
selector:
matchLabels:
app: nginx
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: my-webserver
image: quay.io/jitesoft/nginx
ports:
- containerPort: 80
protocol: TCP
Depois de executar isso, você poderá ver a implantação com kubectl
, como de costume:
$ kubectl -n my-namespace get pods
NAME READY STATUS
nginx-deploy-7fdc9-t9wc2 1/1 Running
Módulos para a nuvem
À medida que mais desenvolvimento e implantações migram para a nuvem, é importante entender como automatizar os aspectos importantes da sua nuvem. Os módulos k8s
e podman_image
são apenas dois exemplos de módulos relacionados ao Kubernetes e uma mera fração de módulos desenvolvidos para a nuvem. Dê uma olhada em seu fluxo de trabalho, encontre as tarefas que deseja monitorar e automatizar e veja como o Ansible pode ajudá-lo a fazer mais fazendo menos.