Pesquisa de site

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.

Baixe a folha de dicas do Ansible k8s

Artigos relacionados: