Tutorial de Marionetes para Iniciantes: Noções Básicas e DSL

O Puppet é uma ferramenta de gerenciamento de configuração de código aberto que permite definir infraestrutura como código e manter grandes conjuntos de servidores em um estado consistente e repetível. Antes de aprendermos sobre o Puppet, vamos primeiro entender o que é gerenciamento de configuração.

O que é Gerenciamento de Configuração?

O gerenciamento de configuração é o processo de manter softwares e sistemas de computador — como servidores, armazenamento e redes — em um estado conhecido, desejado e consistente. Ele também fornece acesso a um registro histórico preciso do estado do sistema para fins de gerenciamento de projetos e auditoria.

Os administradores de sistemas geralmente executam tarefas repetitivas, como instalar e configurar servidores. Esses profissionais podem automatizar esse trabalho escrevendo scripts.

No entanto, essa tarefa se torna difícil quando se trabalha com uma infraestrutura de grande porte. Ferramentas de gerenciamento de configuração, como o Puppet, foram introduzidas para resolver esses problemas.

O que é Marionete?

Fantoche O Puppet é uma ferramenta de gerenciamento de sistemas para centralizar e automatizar o processo de gerenciamento de configuração. Ele também é usado como ferramenta de implantação de software.

É um software de gerenciamento de configuração de código aberto, amplamente utilizado para configuração, gerenciamento, implantação e orquestração de diversos aplicativos e serviços em toda a infraestrutura de uma organização.

O Puppet foi especialmente projetado para gerenciar a configuração do Linux e Windows sistemas. Está escrito em Ruby e usa seu exclusivo DOMain Specífico Llinguagem (DSL) para descrever a configuração do sistema.

Quais são as versões do Puppet?

O fantoche vem em duas versões:

• Fantoche de código abertoÉ uma versão básica da ferramenta de gerenciamento de configuração Puppet, também conhecida como Puppet de código aberto. Está disponível diretamente no site da Puppet e é licenciada sob o sistema Apache 2.0.

• Puppet EnterpriseUma versão comercial que oferece recursos como relatórios de conformidade, orquestração, controle de acesso baseado em funções, uma interface gráfica de usuário (GUI), uma API e ferramentas de linha de comando para o gerenciamento eficaz de nós.

O que o fantoche pode fazer?

Por exemplo, imagine que você tenha uma infraestrutura com cerca de 100 servidores. Como administrador de sistemas, sua função é garantir que todos esses servidores estejam sempre atualizados e funcionando com todas as funcionalidades em pleno funcionamento.

Para isso, você pode usar o Puppet, que permite escrever código simples que pode ser implantado automaticamente nesses servidores. Isso reduz o esforço humano e torna o processo de desenvolvimento mais rápido e eficaz.

O fantoche executa as seguintes funções:

• O Puppet permite definir configurações distintas para cada host.
• A ferramenta permite monitorar continuamente os servidores para confirmar se a configuração necessária existe e não foi alterada. Caso a configuração seja alterada, o Puppet reverte para a configuração predefinida no host.
• Também proporciona controle sobre todos os sistemas configurados, de modo que uma alteração centralizada seja automaticamente efetivada em todos os lugares.
• Também é utilizado como ferramenta de implantação, pois implanta automaticamente o software no sistema. Ele implementa Infraestrutura como código, porque as políticas e configurações são escritas em código.

Puppet DSL e paradigmas de programação

Antes de aprendermos a DSL do Puppet, vamos entender os paradigmas de programação. Um paradigma de programação é um estilo que você usa na programação de computadores.

Quatro tipos de paradigmas são:

• Imperativo.
• Declarativo.
• Funcional (que é considerado um subconjunto do paradigma declarativo).
• Orientado a Objeto.

Vamos nos concentrar nos paradigmas imperativo e declarativo.

Paradigmas Imperativos

Este paradigma de programação expressa a lógica de uma computação (o que fazer) e também descreve seu fluxo de controle (como fazer).

Exemplo:

Imagine que você está indo para o escritório. Você chama um táxi e começa a dar instruções passo a passo ao motorista até chegar ao escritório. Especificar o que fazer e como fazer é um estilo imperativo.

Paradigmas Declarativos

Esse paradigma de programação expressa a lógica de uma computação (o que fazer) sem descrever seu fluxo de controle (como fazer).

Exemplo:

Imagine que você está indo para o escritório. Você reserva um Uber e especifica apenas o destino final (o escritório). Especificar o que fazer, mas não como fazer, é um estilo declarativo.

Paradigm	O que fazer	Como fazer
imperativo	Sim	Sim
Declarativo	Sim	Não

Puppet usa um paradigma de programação declarativo

O Puppet usa uma abordagem de programação declarativa.

Exemplo: Criar um usuário no sistema.

Isso pode ser feito usando um padrão de programação imperativa com um script de shell. Aqui, especificamos como criar o usuário e quais comandos usar no script. sistema operativo.

No entanto, isso também pode ser feito usando um padrão de programação declarativa com apenas algumas linhas de código Puppet e a linguagem específica de domínio (DSL) do Puppet, e ainda assim alcançar o mesmo resultado.

Modelos de implantação de ferramentas de gerenciamento de configuração

Existem dois modelos de implantação para ferramentas de gerenciamento de configuração:

• Modelo de implantação baseado em push: iniciado por um nó mestre.
• Modelo de implantação baseado em pull: iniciado por agentes.

Modelo de implantação baseado em push

Nesse modelo de implantação, o servidor mestre envia as configurações e o software para os agentes individuais. Após verificar uma conexão segura, o mestre executa comandos remotamente nos agentes. Por exemplo, Ansible e pilha de sal.

Modelo de implantação baseado em pull

Nesse modelo de implantação, os servidores individuais contatam um servidor mestre, verificam e estabelecem uma conexão segura, baixam suas configurações e softwares e, em seguida, se configuram de acordo — por exemplo, Puppet e Chef.

Como funciona o fantoche?

O Puppet é baseado em um modelo de implantação pull, onde os nós agentes fazem check-in regularmente — após cada 1800 segundos — com o nó mestre para verificar se algo precisa ser atualizado no agente. Se uma atualização for necessária, o agente obtém o código Puppet necessário do mestre e executa as ações necessárias.

Vamos explicar isso com um exemplo de uma configuração mestre-agente.

O Mestre

Trata-se de uma máquina baseada em Linux com o software Puppet instalado. Ela é responsável por manter as configurações na forma de código Puppet. O nó mestre só pode ser Linux.

Os Agentes

Essas são as máquinas de destino gerenciadas pelo Puppet, com o software agente do Puppet instalado nelas.

O agente pode ser configurado em qualquer sistema operacional compatível, como o Linux. Windows, Solarisou Mac OS.

A comunicação entre o servidor principal e o agente é estabelecida por meio de certificados de segurança.

Comunicação entre o Mestre e o Agente

Passo 1) Assim que a conectividade entre o agente e o servidor mestre é estabelecida, o agente Puppet envia dados sobre seu estado para o servidor mestre Puppet. Esses dados são chamados de "Fatos" e incluem o nome do host, detalhes do kernel, endereço IP, detalhes do nome do arquivo e assim por diante.

Passo 2) O servidor Puppet usa esses dados e compila uma lista das configurações a serem aplicadas ao agente. Essa lista de configurações a serem executadas em um agente é conhecida como lista de configurações. catálogoIsso pode incluir instalação, atualização ou remoção de pacotes, criação de sistemas de arquivos, criação ou exclusão de usuários, reinicialização do servidor, alterações na configuração de IP e assim por diante.

Passo 3) O agente usa esta lista de configurações para aplicar quaisquer alterações de configuração necessárias no nó.

Se não houver desvios na configuração, o agente não realiza nenhuma alteração de configuração e deixa o nó em execução com a mesma configuração.

Passo 4) Assim que concluído, o nó envia um relatório ao servidor Puppet, indicando que a configuração foi aplicada e finalizada.

Blocos de fantoches

O Puppet oferece a flexibilidade de integrar relatórios com ferramentas de terceiros usando APIs do Puppet.

Os quatro tipos de blocos de construção de marionetes são:

1. Recursos
2. Classes
3. Manifesto
4. Módulos

Recursos de fantoches

Os recursos do Puppet são os blocos de construção do Puppet.

Os recursos são os funções integradas que são executadas em segundo plano para realizar as operações necessárias no Puppet.

Aulas de fantoches

Uma combinação de diferentes recursos pode ser agrupada em uma única unidade chamada classe.

Manifesto de Marionetes

Um manifesto é um diretório que contém arquivos DSL do Puppet. Esses arquivos têm a extensão .pp, que significa programa Puppet. O código Puppet consiste em definições ou declarações de classes Puppet.

Módulos de fantoches

Os módulos são uma coleção de arquivos e diretórios, como manifestos e definições de classe. Eles são as unidades reutilizáveis ​​e compartilháveis ​​no Puppet.

Por exemplo, a MySQL O módulo instala e configura. MySQL, e a Jenkins módulo gerencia Jenkins.

Tipos de recursos do Puppet

Em geral, um sistema consiste em arquivos, usuários, serviços, processos, pacotes e assim por diante. No Puppet, esses elementos são chamados de recursos e constituem os blocos de construção fundamentais do Puppet.

Todas as operações nos agentes Puppet são realizadas com o auxílio dos recursos do Puppet.

Os recursos do Puppet são ferramentas prontas para uso que permitem executar diversas tarefas e operações em qualquer plataforma compatível. Podemos usar um único recurso do Puppet para realizar uma tarefa específica ou vários recursos do Puppet em conjunto para realizar implantações complexas de configuração de aplicativos.

Os recursos podem ter diferentes tipos. Usos de fantoches recursos e tipos de recursos para descrever a configuração de um sistema.

Existem três tipos de recursos:

1. Núcleo do fantoche ou tipos de recursos integrados.
2. Tipos de recursos definidos pelo fantoche.
3. Tipos de recursos personalizados do Puppet.

Núcleo do fantoche ou tipos de recursos integrados

Os tipos de recursos principais ou integrados são os tipos de recursos pré-construídos do Puppet que acompanham o software. Todos os tipos de recursos principais ou integrados do Puppet são escritos e mantidos pela equipe do Puppet.

Tipos de recursos definidos por fantoches

Os tipos de recursos definidos são tipos de recursos leves escritos na linguagem declarativa do Puppet, usando uma combinação de tipos de recursos existentes.

Tipos de recursos personalizados do Puppet

Os tipos de recursos personalizados são tipos de recursos totalmente personalizados escritos em Ruby.

Vamos explorar mais detalhadamente os tipos de recursos do Puppet.

No terminal, digite o seguinte comando para exibir uma lista de subcomandos relacionados ao Puppet:

Puppet --help

No nosso caso, estamos interessados ​​no subcomando “recurso“, que usaremos para encontrar informações sobre os tipos de recursos integrados do Puppet.

No terminal, digite qualquer um dos seguintes comandos para exibir uma lista de Ações associado ao subcomando Puppet “recurso":

Puppet help resource		
Puppet resource --help		

Nesse caso, temos recurso como o subcomando e –tipos como a ação.

O Puppet possui 49 tipos de recursos principais integrados.

No terminal, digite o seguinte comando para exibir uma lista dos tipos de recursos integrados do Puppet disponíveis:

puppet resource –types

Cada tipo suporta uma lista de atributos. Esses atributos fornecem uma descrição detalhada que o Puppet usa para gerenciar o recurso.

Para descobrir todos os atributos associados a um tipo de recurso do Puppet, use o seguinte comando:

puppet describe <resource type name>	

Os parâmetros listarão todos os atributos disponíveis para esse tipo de recurso.

pacote de descrição de fantoches

Para um iniciante, é difícil entender e relacionar muitos arquivos de código Puppet não gerenciados. É aí que precisamos de algum suporte em grupo.ping Integrar operações. O objetivo é resolver um único problema, como todas as operações necessárias para configurar o SSH em um servidor, um serviço NTP ou um servidor web ou de banco de dados completo do zero.

O que são aulas de fantoches?

As aulas de fantoches são coleções de recursos de fantoches agrupados em uma única unidade.

O Puppet introduziu classes para tornar a estrutura reutilizável e organizada.

Primeiro, precisamos definir uma classe usando a sintaxe de definição de classe. As classes devem ser únicas e podem ser declaradas apenas uma vez com o mesmo nome:

class <class-name> {
<Resource declarations>
}

Exemplo:

class ntpconfig {
    file {
        "/etc/ntp.conf": 
     ensure=> "present", content=> "server 0.centos.pool.ntp.org iburst\n",
    }
}

Até agora, apenas definimos a classe; não a utilizamos em nenhum lugar. Isso significa que o código que escrevemos nunca será executado a menos que declaremos essa classe em outro lugar.

Declaração de Classe

Para usar uma classe definida em seu código, use o incluir palavra chave.

class ntpconfig {
    file {
        "/etc/ntp.conf": 
      ensure=> "present", 
      content=> "server 0.centos.pool.ntp.org iburst\n",
    }
}
include ntpconfig

Vamos entender isso com um cenário do mundo real.

Instalação de demonstração NTP

Primeiro, verifique se o pacote NTP ainda não está presente no servidor. O comando a seguir não retornará nada se o pacote NTP não estiver presente no servidor:

rpm -qa | grep -i ntp

Como podemos ver, o pacote NTP já está presente no servidor. Vamos remover o pacote NTP existente:

yum remove ntp

Após remover o pacote, certifique-se de que o arquivo ntp.conf não exista mais:

ls -lrt /etc/ntp.conf

Verifique se o serviço NTP não existe executando o seguinte comando:

systemctl status ntp

Crie um novo arquivo .pp para salvar o código. Na linha de comando:

vi demontp.pp

Alterne para o modo de inserção pressionando a tecla "i" no teclado.

Digite o seguinte código para criar um novo arquivo:

# Class Definition 
class ntpconfig {
    # Installing NTP Package 
  package {"ntp": 
    ensure=> "present",
    }
    # Configuring NTP configuration file 
  file {"/etc/ntp.conf": 
    ensure=> "present", 
    content=> "server 0.centos.pool.ntp.org iburst\n",
    }
    # Starting NTP services 
  service {"ntpd": 
    ensure=> "running",
    }
}

Após concluir a edição, pressione Esc.

Para salvar o arquivo, pressione :wq!

O próximo passo é verificar se o código contém algum erro de sintaxe. Execute o seguinte comando:

puppet parser validate demontp.pp

Certifique-se de ter mudado para o raiz O usuário poderá concluir o teste sem erros, executando o seguinte comando:

su root

Testar é a próxima etapa no processo de criação de código. Execute o seguinte comando para realizar um teste de fumaça:

Puppet applies demontp.pp --noop

A última etapa é corrida Execute o fantoche no modo real e verifique a saída.

puppet apply demontp.pp

O Puppet não executou nada porque a aula de demonstração era apenas isso: definido mas não Declarado.

Portanto, até que você declare a classe Puppet, o código não será aplicado.

Vamos declarar a classe demo dentro do mesmo código usando incluir o nome da classe no final do código:

# Class Definition 
class ntpconfig {
    # Installing NTP Package 
  package {"ntp": 
    ensure=> "present",
    }
    # Configuring NTP configuration file 
  file {"/etc/ntp.conf": 
    ensure=> "present", 
    content=> "server 0.centos.pool.ntp.org iburst\n",
    }
    # Starting NTP services 
  service {"ntpd": 
    ensure=> "running",
    }
}

# Class Declaration 
include ntpconfig

Mais uma vez, verificar se o código contém algum erro de sintaxe. Execute o seguinte comando:

puppet parser validate demontp.pp

Certifique-se de ter mudado para o raiz O usuário poderá concluir o teste sem erros, executando o seguinte comando:

su root

Testes é a próxima etapa no processo de criação de código. Execute o seguinte comando para realizar um teste de fumaça:

Puppet apply demontp.pp --noop

A última etapa é corrida Execute o fantoche no modo real e verifique a saída.

puppet apply demontp.pp

Desta vez, o código é aplicado porque a classe foi definida e depois declarada.

Certifique-se de que o arquivo ntp.conf agora existe:

ls -lrt /etc/ntp.conf

Verifique se o serviço NTP foi iniciado executando o seguinte comando:

systemctl status ntpd

Perguntas Frequentes