Configure o Chef Knife, carregue livros de receitas e execute uma receita em Chef Client Nodes

Em nosso último artigo, vimos como instalar o Chef Server no Ubuntu 20.04, Ubuntu 18.04 e CentOS 8. Tentarei fazer um guia de instalação do Chef Server no CentOS 7 também. Esta postagem do blog sobre como configurar o Chef Knife, escrever um livro de receitas de teste e carregá-lo no Chef Server e, finalmente, executar este livro de receitas em um servidor (nó) pretende ser uma continuação – Entrega conforme prometido.

Pré-requisitos de configuração

• Chef Server e estação de trabalho instalados: Ubuntu 20.04, Ubuntu 18.04 e CentOS 8

Para usuários do Arch Linux, use: Como instalar o Chef Development Kit no Arch Linux

Ao instalar o Chef Workstation, você receberá o comando knife . Certifique-se de ter instalado o Chef Server e configurado o Chef Workstation antes de prosseguir com este guia. Quando tudo estiver configurado e pronto, podemos começar a explorar a configuração e o uso do Knife.

Curso de vídeo de aprendizagem de chef:

Introdução à faca

Knife é uma ferramenta de linha de comando que fornece uma interface entre sua estação de trabalho e o servidor Chef. A faca permite que você carregue seus livros de receitas para o servidor Chef e interaja com os nós, os servidores que você gerencia.

Em resumo, a faca permite gerenciar:

• Nós – Servidores gerenciados pelo Chef
• Livros de receitas e receitas
• Funções, ambientes e pacotes de dados
• Recursos em vários ambientes de nuvem
• A instalação do chef-client em nós
• Procurando dados indexados no servidor Chef

Knife requer dois arquivos para autenticação no servidor Chef.

1. Uma chave privada RSA:

• Cada solicitação ao servidor Chef é autenticada por meio de um par de chaves públicas RSA.
• O servidor Chef contém a parte pública; você segura a parte privada.

2. Um arquivo de configuração de faca

• O arquivo de configuração normalmente é denominado knife.rb.
• Este arquivo de configuração contém informações como oURL do servidor Chef, alocalização da sua chave privada RSA e a localização padrão dos seus livros de receitas.
• Ambos os arquivos normalmente estão localizados em um diretório chamado .chef
• Por padrão, toda vez que o Knife é executado, ele procura no diretório de trabalho atual o diretório .chef
• Se o diretório .chef não existir, o Knife pesquisa na árvore de diretórios um diretório .chef

Configurar o ambiente Knife (na máquina da estação de trabalho)

Nesta seção, configuraremos o Knife para poder se comunicar com o Chef Server.

Etapa 1: gerar o diretório do repositório do chef

Comece gerando um repositório Chef em sua máquina Workstation

chef generate repo chef-repo
cd chef-repo

O diretório chef repo deve ter

$ ls -1
chefignore
cookbooks
data_bags
environments
LICENSE
README.md
roles

Etapa 2: configurar o Git

O ChefDK adiciona o componente Git à sua estação de trabalho e inicializa um repositório Git no diretório usado para gerar o repositório Chef.

O único trabalho que você tem é configurar o Git para adicionar seu nome de usuário e e-mail e adicionar e submeter quaisquer novos arquivos gerados.

git config --global user.name gitusername
git config --global user.email [email 

Etapa 3: adicione o diretório .chef ao arquivo .gitignore

Você precisa dizer ao Git para ignorar o rastreamento de todos os arquivos no diretório .chef

echo ".chef" > .gitignore

Adicione arquivos e confirme

git add .
git commit -m "initial commit"

Etapa 4: configurar a faca

Crie um diretório .chefdentro da pastachef-repo.

cd chef-repo
mkdir .chef
cd .chef

O diretório .chef deve conter dois arquivos:

• Seu arquivo de configuração da faca, knife.rb
• Sua chave privada RSA

Baixe sua chave privada RSA do Chef Server – Ela foi gerada durante a instalação do Chef server, consulte Como instalar o Chef Automation Server no Ubuntu 18.04 LTS

$ scp chef-server:/home/chefadmin.pem .

Substitua chef-server pelo endereço do Chef Server e /home/chefadmin.pem pela localização da sua chave privada.

Crie o arquivo knife.rb

$ vim knife.rb

Adicione o conteúdo semelhante ao abaixo

current_dir = File.dirname(__FILE__)
log_level :info
log_location STDOUT
node_name "chefadmin"
client_key "#{current_dir}/chefadmin.pem"
chef_server_url "https://chef-server/organizations/mycompany"
cookbook_path ["#{current_dir}/../cookbooks"]

• minhaempresa deve corresponder ao nome da sua organização conforme criada no servidor Chef
• chef-server é o nome de domínio do seu Chef Server – resolvível na máquina da estação de trabalho
• chefadmin deve ser o nome de usuário criado no servidor chef

Você também pode usar o Validador da Organização, mas primeiro baixe a Chave Privada do validador.

$ scp chef-server:/home/mycompany-validator.pem .

Em seguida, configure a faca:

current_dir = File.dirname(__FILE__)
log_level :info
log_location STDOUT
node_name 'chefadmin'
client_key "#{current_dir}/chefadmin.pem"
validation_client_name 'mycompany-validator'
validation_key "#{current_dir}/mycompany-validator.pem"
chef_server_url "https://chef-server/organizations/mycompany"
cookbook_path ["#{current_dir}/../cookbooks"]

Obtenha o certificado SSL do seu servidor Chef.

$ knife ssl fetch

Valide o certificado SSL baixado

$ knife ssl check
Connecting to host chef-server:443
Successfully verified certificates from `chef-server'

$ file trusted_certs/chef-server.crt
trusted_certs/chef-server.crt: PEM certificate

Confirme se o knife.rb está configurado corretamente executando a lista de clientes:

$ knife client list

Este comando deve gerar o nome do validador.

Escreva um livro de receitas do Chef de teste

Nesta seção, criaremos um livro de receitas simples para instalar e configurar o servidor web Apache com uma página da web Hello Chef World .

Etapa 1: gerar livro de receitas

Gere um livro de receitas usando a sintaxe do comando:

chef generate cookbook COOKBOOK_PATH/COOKBOOK_NAME (options)

Como exemplo, vamos nomear nosso livro de receitas como iapache_server

$ cd chef-repo
$ chef generate cookbook  cookbooks/install_apache

Generating cookbook apache_server
- Ensuring correct cookbook file content
- Ensuring delivery configuration
- Ensuring correct delivery build cookbook content

Your cookbook is ready. Type `cd cookbooks/install_apache` to enter it.

There are several commands you can run to get started locally developing and testing your cookbook.
Type `delivery local --help` to see a full list.

Why not start by writing a test? Tests for the default recipe are stored at:

test/integration/default/default_test.rb

If you'd prefer to dive right in, the default recipe can be found at:

recipes/default.rb

Etapa 2: gerar modelo de página de índice HTML

Um modelo de livro de receitas é um modelo Embedded Ruby (ERB) usado para gerar dinamicamente arquivos de texto estáticos. Gere o modelo index.html que será copiado para o servidor Apache

$ cd cookbooks
$ chef generate template install_apache index.html
Recipe: code_generator::template
  * directory[./install_apache/templates] action create
    - create new directory ./install_apache/templates
  * template[./install_apache/templates/index.html.erb] action create
    - create new file ./install_apache/templates/index.html.erb
    - update content in file ./install_apache/templates/index.html.erb from none to e3b0c4
    (diff output suppressed by config)

Edite o arquivo index.html.erb

$ vim install_apache/templates/index.html.erb

Aqui está uma amostra

<html>
  <body>
    <h1>Hello Chef World from <%= node['fqdn'] %></h1>
  </body>
</html>

A sintaxe <%= %> permite fornecer espaços reservados em seu arquivo de modelo. Os espaços reservados são substituídos por seus valores quando chef-client é executado

O atributo node['fqdn'] um nome de domínio totalmente qualificado para um nó. É usado como o nome de um nó, a menos que seja definido de outra forma.

Etapa 3: crie uma receita para Apache

Agora crie uma receita de servidor web Apache que tenha definições de recursos para:

• Instale pacotes básicos do sistema – vim, bash-completion, curl e wget
• Instale o pacote do servidor web Apache – httpd para CentOS/RHEL/Fedora e apache2 para a família Debian
• Inicie o serviço Apache e configure-o para iniciar na inicialização
• Copie o modelo index.html.erb para /var/www/html/index.html

Aqui está o arquivo de receita completo install_apache/recipes/default.rb

#
# Cookbook:: install_apache
# Recipe:: default
#
# Copyright:: 2018, The Authors, All Rights Reserved.

# Install basic packages

package 'Install basic packages' do
  package_name %w(vim wget curl bash-completion)
end


# Install Apache web server
package 'Install Apache web server' do
  case node[:platform]
  when 'redhat', 'centos', 'fedora'
    package_name 'httpd'
  when 'ubuntu', 'debian'
    package_name 'apache2'
  end
end

# Start and enable the service

service 'Start and enable apache service' do
  case node[:platform]
  when 'redhat', 'centos', 'fedora'
    service_name 'httpd'
  when 'ubuntu', 'debian'
    service_name 'apache2'
  end
  action [:enable, :start]
end

# Copy apache template

template '/var/www/html/index.html' do
  source 'index.html.erb'
  mode '0644'
  case node[:platform]
  when 'redhat', 'centos', 'fedora', 'scientific'
    owner 'apache'
    group 'apache'
  when node[:platform]
    owner 'www-data'
    group 'www-data'
  end
end

Além disso, edite seu arquivo de metadados para especificar a versão do livro de receitas e o URL do repositório Git para o mesmo.

vim install_apache/metadata.rb

O meu tem o seguinte conteúdo:

################################
name 'install_apache'
maintainer 'Josphat Mutai'
maintainer_email '[email '
license 'All Rights Reserved'
description 'Installs/Configures install_apache'
long_description 'Installs/Configures Apache Web Server'
version '0.1.0'
chef_version '>= 13.0'

# The `issues_url` points to the location where issues for this cookbook are
# tracked.  A `View Issues` link will be displayed on this cookbook's page when
# uploaded to a Supermarket.
#
# issues_url 'https://github.com/<insert_org_here>/install_apache/issues'

# The `source_url` points to the development repository for this cookbook.  A
# `View Source` link will be displayed on this cookbook's page when uploaded to
# a Supermarket.
#
# source_url 'https://github.com/<insert_org_here>/install_apache'

Etapa 4: fazer upload do livro de receitas para o Chef Server

Temos nosso livro de receitas de teste pronto para ser carregado no Chef Server.

$ knife cookbook upload install_apache
Uploading install_apache [0.1.0]
Uploaded 1 cookbook.

Confirme listando livros de receitas no Chef Server

$ knife cookbook list
chef-client      11.0.1
cron             6.2.1
install_apache   0.1.0
logrotate        2.2.0

Inicializando um nó

O knife bootstrap é o comando que você usa para inicializar um nó. Ao usar este comando, você especifica argumentos dependendo de como você normalmente se conectaria ao seu nó por SSH.

Você pode se conectar ao Node via:

• Autenticação baseada em chave
• Autenticação de senha

A autenticação baseada em chave normalmente é recomendada em vez da autenticação por senha porque é mais segura, mas você pode inicializar seu nó usando qualquer um dos métodos. Em ambos os métodos, o argumento --node-name identifica exclusivamente o nó com o servidor Chef e seu valor pode ser o que você quiser.

Opções gerais usadas com o comando knife bootstrap 

--ssh-user
--sudo
--node-name
--run-list

Opções específicas para autenticação baseada em chave

--identity-file

Opções específicas para autenticação por senha

--ssh-password
--use-sudo-password

Bootstrap um nó usando autenticação por senha

A sintaxe do comando é:

$ knife bootstrap ADDRESS --ssh-user USER --sudo --node-name nodename --run-list 'recipe[recipe-name]'

Separe várias receitas com vírgula

'recipe[nginx],recipe[php-fpm],recipe[haproxy]'

Para nosso caso de exemplo, usaremos:

$ knife bootstrap 192.168.18.9 -x vagrant --sudo -P 'vagrant' -N  centos-01 -r 'recipe[install_apache]'

Substituir :

• ADDRESS com o endereço externo do seu nó remoto,
• USER com seu nome de usuário
• centos-01 com o nome do seu nó
• install_apache com nome do livro de receitas

Para usar o usuário root

$ knife bootstrap 192.168.18.11 -x root  -P 'password' -N  centos-01 \
-r 'recipe[install_apache]'

Se você receber uma mensagem de erro como ERROR: Net::SSH::HostKeyMismatch: fingerprint ..does not match for "IP", talvez seja necessário remover a chave incorreta do seu ~/ .ssh/config usando:

$ ssh-keygen -R IPADDRESS

Ou inicialize com a opção --no-host-key-verify (não recomendado porque é menos seguro)

$ knife bootstrap IPADDRESS --no-host-key-verify <OPTIONS>

Para Bootstrap usando autenticação de chave

$ knife bootstrap 192.168.18.9 -x vagrant --sudo  --identity-file ~/.ssh/private_key \
-N  centos-01 -r 'recipe[install_apache]'

O Knife Node Bootstrap irá:

• Faça login no nó
• Instalar chef-cliente
• Configurar chef-cliente
• Execute chef-cliente

Exemplo de saída:

Para confirmar o resultado, verifique se o seu nó estava associado ao seu servidor Chef.

$ knife node list
centos-01

Você pode usar o comandoknife node show para visualizar dados sobre seu nó.

$ knife node show centos-01
Node Name:   centos-01
Environment: _default
FQDN:        cent-01
IP:          192.168.121.136
Run List:    recipe[install_apache]
Roles:       
Recipes:     install_apache, install_apache::default
Platform:    centos 7.5.1804
Tags:

Abra o endereço IP do nó em seu navegador para ver se nossa página da web está funcionando

Atualize a configuração do seu nó

O comando knife ssh permite que você atualize a configuração do seu nó quando o seu livro de receitas for alterado. Para atualizar seu nó usando autenticação de senha com atributos

knife ssh 'name:nodename' 'sudo chef-client' --ssh-user USER --ssh-password 'PASSWORD' --attribute ipaddress

Excluir dados do nó

O Chef faz uma distinção entre os nós que estão sendo gerenciados e os clientes autorizados a fazer chamadas de API para o servidor do Chef. Exclua os dados do nó executando:

knife node delete nodename --yes
knife client delete nodename --yes

O knife node delete remove os metadados do nó do servidor Chef e o knife client delete  exclui a entrada (incluindo a parte pública do par de chaves RSA) do cliente API do servidor Chef lista.

Excluir Chef Cookbook/roles e chave privada RSA

Para excluir seu livro de receitas do servidor Chef

knife cookbook delete cookbookname --all --yes

Se você omitir o argumento --all, você será solicitado a selecionar qual versão excluir

Para excluir a função do servidor Chef

$ knife role delete myrole --yes

Exclua a chave privada RSA do seu nó

Durante o processo de inicialização, uma chave privada RSA é gerada no seu nó para permitir que ele faça chamadas de API para o servidor Chef. Essa chave é salva em /etc/chef/client.pem em sistemas Linux

Se você planeja inicializar seu nó uma segunda vez, por exemplo, para praticar o processo, você precisará fazer login em seu nó e excluir o arquivo de chave privada RSA, como este

$ sudo rm /etc/chef/client.pem

Espero que este artigo tenha sido útil para pessoas novas no Knife e no Chef Automation Engine. Fique ligado para mais artigos do Chef.

Curso de vídeo de aprendizagem de chef: