Ansible e as artes do pré-contentor

Tutoriais
Kubernetes Ubuntu

Antes de a contentorização tornar tão fácil a preparação de imagens para virtualização, era uma arte preparar imagens ISO personalizadas para arrancar a partir de CD. Mais tarde, essas imagens foram usadas para inicializar máquinas virtuais. Em outras palavras, as imagens ISO foram precursoras das imagens de contêineres.

É por isso que eu tive alguns encontros infelizes com o cliente Docker do Windows. Mesmo quando não estava a correr nenhum contentor, o gestor de memória do Windows entregava-lhe o máximo de memória possível, abrandando aquilo com que eu estava ocupado. Por isso, bani o cliente Docker do Windows da minha máquina.

Por favor, não me interpretem mal. Eu não odeio o Docker – apenas seu cliente Windows.

Este passo me forçou a voltar no tempo. Comecei a rodar máquinas virtuais diretamente no Hyper-V, o Hypervisor do Windows. Formar clusters de Kubernetes no Windows se tornou um hobby feliz para mim como pode ser visto nos meus posts anteriores publicados aqui no DZone.

Sapateiro, por que você anda descalço?

Depois de seguir os mesmos cliques do mouse para criar máquinas virtuais no Hyper-V Manager por muitas horas, percebi que sou como um sapateiro que anda descalço: Eu construo um pipeline DevOps por uma taxa horária, mas perco tempo com cliques de mouse?

Desafio aceite. Eu fiz um duckduckgo’d e li que é possível criar máquinas virtuais usando o PowerShell. Não demorou uma semana para ter um script que cria uma nova máquina virtual como pode ser visto aqui. Um script irmão pode iniciar uma máquina virtual que está desligada.

Uma velha arte redescoberta

Isso foi ótimo, mas percebi que ainda estava fazendo cliques do mouse ao instalar o Ubuntu. Automatizar isso parecia ser uma tarefa mais difícil. É preciso descompactar uma imagem ISO, manipulá-la de uma forma ou de outra e depois empacotá-la novamente, tomando cuidado para deixar intacto o que quer que instrua um computador a inicializar.

Felizmente, encontrei um excelente guia sobre como fazer exatamente isso. O processo consiste em três etapas:

  1. Desempacotar a imagem de inicialização ISO do Ubuntu.
  2. Manipular o conteúdo:
    1. Mover o registo mestre de arranque (MBR) para fora

      2. .

    2. Especifique o que os utilizadores normalmente fazem na GUI e personalize o que é instalado e executado durante a instalação. Isso é feito usando um subconjunto da linguagem Cloud-init do Ubuntu. Veja aqui para as instruções que criei.
    3. Instruir o carregador de inicialização (Grub, neste caso) onde encontrar as instruções de inicialização personalizadas e não esperar pela entrada do usuário. Aqui está a configuração do Grub que eu escolhi.
  3. Embale tudo isso usando um aplicativo chamado Xorriso.

Para os feiticeiros desta antiga arte, o Xorriso serve como a sua varinha mágica. Ele tem páginas de documentação em algo que se assemelha a um livro de feitiços. Vou ter que sujar as mãos para entender completamente, mas meu entendimento atual (e provavelmente falho) é que ele cria partições de Boot, carrega o MBR copiado e faz algo com as instruções do Cloud-init para criar uma imagem ISO alterada.

Ansible for the Finishing Touches

Embora tenha sido com grande satisfação que consegui inicializar o Ubuntu22 a partir do PowerShell sem nenhuma outra contribuição minha, o que dizer da próxima vez que o Ubuntu lançar uma nova versão? O verdadeiro DevOps obriga a documentar o processo não em ASCII, mas em algum script pronto para ser executado quando necessário. O Ansible mostra a sua versatilidade, pois consegui fazer isso numa tarde. O segredo é instruir o Ansible de que se trata de uma ação local. Em outras palavras, não usar SSH para direcionar uma máquina para receber instruções, mas o controlador do Ansible também é o aluno:

YAML

  

- hosts: localhost
  connection: local

A jogada completa é dada a seguir e fornece outra visão do que foi explicado acima:

YAML

  

# stamp_images.yml

- hosts: localhost
  connection: local
  become: true
  vars_prompt:
    - name: "base_iso_location"
      prompt: "Enter the path to the base image"
      private: no
      default: /tmp/ubuntu-22.04.4-live-server-amd64.iso

  tasks:
    - name: Install 7Zip
      ansible.builtin.apt:
        name: p7zip-full
        state: present

    - name: Install Xorriso
      ansible.builtin.apt:
        name: xorriso
        state: present

    - name: Unpack ISO
      ansible.builtin.command: 
        cmd: "7z -y x {{ base_iso_location }} -o/tmp/source-files"

    - name: Copy boot partitions
      ansible.builtin.copy:
        src: /tmp/source-files/[BOOT]/
        dest: /tmp/BOOT
  
    - name: Delete working boot partitions
      ansible.builtin.file:
        path:  /tmp/source-files/[BOOT]
        state: absent
  
    - name: Copy files for Ubuntu Bare
      ansible.builtin.copy:
        src: bare/source-files/bare_ubuntu
        dest: /tmp/source-files/

    - name: Copy boot config for Ubuntu bare
      ansible.builtin.copy:
        src: bare/source-files/boot/grub/grub.cfg
        dest: /tmp/source-files/boot/grub/grub.cfg

    - name: Stamp bare image
      ansible.builtin.command: 
        cmd: xorriso -as mkisofs -r   -V 'Ubuntu 22.04 LTS AUTO (EFIBIOS)'   -o ../ubuntu-22.04-wormhole-autoinstall-bare_V5_1.iso   --grub2-mbr ../BOOT/1-Boot-NoEmul.img -partition_offset 16   --mbr-force-bootable   -append_partition 2 28732ac11ff8d211ba4b00a0c93ec93b ../BOOT/2-Boot-NoEmul.img   -appended_part_as_gpt   -iso_mbr_part_type a2a0d0ebe5b9334487c068b6b72699c7   -c '/boot.catalog'   -b '/boot/grub/i386-pc/eltorito.img'     -no-emul-boot -boot-load-size 4 -boot-info-table --grub2-boot-info   -eltorito-alt-boot   -e '--interval:appended_partition_2:::'   -no-emul-boot .
        chdir: /tmp/source-files

    - name: Copy files for Ubuntu Atomika
      ansible.builtin.copy:
        src: atomika/source-files/atomika_ubuntu
        dest: /tmp/source-files/

    - name: Copy boot config for Ubuntu Atomika
      ansible.builtin.copy:
        src: atomika/source-files/boot/grub/grub.cfg
        dest: /tmp/source-files/boot/grub/grub.cfg

    - name: Stamp Atomika image
      ansible.builtin.command:
        cmd: xorriso -as mkisofs -r   -V 'Ubuntu 22.04 LTS AUTO (EFIBIOS)'   -o ../ubuntu-22.04-wormhole-autoinstall-atomika_V5_1.iso   --grub2-mbr ../BOOT/1-Boot-NoEmul.img -partition_offset 16   --mbr-force-bootable -append_partition 2 28732ac11ff8d211ba4b00a0c93ec93b ../BOOT/2-Boot-NoEmul.img   -appended_part_as_gpt   -iso_mbr_part_type a2a0d0ebe5b9334487c068b6b72699c7   -c '/boot.catalog'   -b '/boot/grub/i386-pc/eltorito.img'     -no-emul-boot -boot-load-size 4 -boot-info-table --grub2-boot-info   -eltorito-alt-boot   -e '--interval:appended_partition_2:::'   -no-emul-boot .
        chdir: /tmp/source-files

Observe a mágica do comando Xorriso usado aqui para preparar duas imagens: uma com suporte e outra sem suporte ao Kubernetes.

A única ressalva é ter uma máquina instalada com o Ansible para executar essa jogada. A saída do jogo acima pode ser baixada de aqui e pré-instalar uma versão muito recente do Ansible.

Conclusão

Este post foi retro, mas é importante revisitar onde as coisas começaram para entender por que as coisas são como são. Windows e containers, além disso, não se misturam muito bem e qualquer investigação sobre maneiras de tornar os dias dos desenvolvedores melhores deve ser bem-vinda.

Fiz referência a parte do código, mas o projeto completo pode ser visto no GitHub.

Source:
https://dzone.com/articles/ansible-and-the-pre-container-arts