Chef - Guia Rápido

Chef é uma tecnologia de código aberto desenvolvida pela Opscode. Adam Jacob, cofundador da Opscode, é conhecido como o fundador do Chef. Esta tecnologia usa codificação Ruby para desenvolver blocos de construção básicos, como receitas e livros de receitas. O Chef é utilizado na automação de infraestrutura e auxilia na redução de tarefas manuais e repetitivas para gerenciamento de infraestrutura.

O Chef tem sua própria convenção para diferentes blocos de construção, que são necessários para gerenciar e automatizar a infraestrutura.

Por que Chef?

Chef é uma tecnologia de gerenciamento de configuração usada para automatizar o provisionamento da infraestrutura. É desenvolvido com base na linguagem Ruby DSL. É utilizado para agilizar a tarefa de configuração e gerenciamento do servidor da empresa. Ele tem a capacidade de se integrar a qualquer tecnologia de nuvem.

No DevOps, usamos o Chef para implantar e gerenciar servidores e aplicativos internamente e na nuvem.

Características do Chef

A seguir estão as características mais importantes do Chef -

  • O Chef usa a popular linguagem Ruby para criar uma linguagem de domínio específico.

  • Chef não faz suposições sobre o status atual de um nó. Ele usa seus mecanismos para obter o status atual da máquina.

  • O Chef é ideal para implantar e gerenciar o servidor, armazenamento e software em nuvem.

Vantagens do Chef

O Chef oferece as seguintes vantagens -

  • Lower barrier for entry - Como Chef usa a linguagem Ruby nativa para configuração, uma linguagem de configuração padrão pode ser facilmente aprendida por qualquer pessoa com alguma experiência em desenvolvimento.

  • Excellent integration with cloud- Usando o utilitário de faca, pode ser facilmente integrado com qualquer uma das tecnologias de nuvem. É a melhor ferramenta para uma organização que deseja distribuir sua infraestrutura em ambiente multi-nuvem.

Desvantagens do Chef

Algumas das principais desvantagens do Chef são as seguintes -

  • Uma das grandes desvantagens do Chef é a maneira como os livros de receitas são controlados. Ele precisa de cuidados constantes para que as pessoas que estão trabalhando não se atrapalhem com os livros de receitas de outros.

  • Apenas Chef solo está disponível.

  • Na situação atual, é apenas uma boa opção para a nuvem AWS.

  • Não é muito fácil aprender se a pessoa não estiver familiarizada com Ruby.

  • A documentação ainda está faltando.

Principais blocos de construção do Chef

Receita

Ele pode ser definido como uma coleção de atributos que são usados ​​para gerenciar a infraestrutura. Esses atributos que estão presentes na receita são usados ​​para alterar o estado existente ou configurar um nó de infraestrutura específico. Eles são carregados durante a execução do cliente Chef e compartimentados com o atributo existente do nó (máquina). Em seguida, chega ao status definido no recurso de nó da receita. É o carro-chefe do livro de receitas.

Livro de receitas

Um livro de receitas é uma coleção de receitas. Eles são os blocos de construção básicos que são carregados no servidor Chef. Quando a execução do Chef ocorre, ele garante que as receitas presentes nele recebam uma determinada infraestrutura para o estado desejado, conforme listado na receita.

Recurso

É o componente básico de uma receita usada para gerenciar a infraestrutura com diferentes tipos de estados. Pode haver vários recursos em uma receita, o que ajudará na configuração e gerenciamento da infraestrutura. Por exemplo -

  • package - Gerencia os pacotes em um nó

  • service - Gerencia os serviços em um nó

  • user - Gerencia os usuários no nó

  • group - Gerencia grupos

  • template - Gerencia os arquivos com o modelo Ruby incorporado

  • cookbook_file - Transfere os arquivos do subdiretório de arquivos no livro de receitas para um local no nó

  • file - Gerencia o conteúdo de um arquivo no nó

  • directory - Gerencia os diretórios no nó

  • execute - Executa um comando no nó

  • cron - Edita um arquivo cron existente no nó

Atributo

Eles são basicamente configurações. Eles podem ser considerados um par de valores-chave de qualquer coisa que se queira usar no livro de receitas. Existem vários tipos diferentes de atributos que podem ser aplicados, com um nível diferente de precedência sobre as configurações finais sob as quais o nó opera.

Arquivo

É um subdiretório dentro do livro de receitas que contém qualquer arquivo estático que será colocado nos nós que usam os livros de receitas. Uma receita pode então ser declarada como um recurso que move os arquivos desse diretório para o nó final.

Modelos

Eles são semelhantes a arquivos, mas não são estáticos. Os arquivos de modelo terminam com a extensão .ebr, o que significa que contêm Ruby integrado. Eles são usados ​​principalmente para substituir um valor de atributo nos arquivos para criar a versão final do arquivo que será colocada no nó.

Metadata.rb

É usado para gerenciar os metadados sobre o pacote. Isso inclui detalhes como o nome e os detalhes do pacote. Ele também inclui itens como informações de dependência que informam quais livros de receitas esse livro precisa para operar. Isso permite que o servidor Chef construa a lista de execução do nó corretamente e garante que todas as peças sejam transferidas corretamente.

Estrutura do livro de receitas padrão

C:\chef\cookbooks\nginx>tree 
Folder PATH listing for volume Local Disk 
Volume serial number is BE8B-6427 
C: ├───attributes 
├───definitions 
├───files 
│   └───default 
├───libraries 
├───providers 
├───recipes 
├───resources 
└───templates 
    └───default

Chef - Tecnologias Relacionadas

A seguir está a lista de tecnologias relacionadas ao Chef.

Fantoche

O Puppet fornece uma maneira padrão de fornecer e operar software, não importa onde ele seja executado. É um mecanismo administrativo automatizado para sistemas Linux, Unix e Windows que executa tarefas administrativas com base em especificações centralizadas.

O primário features of Puppet são os seguintes -

  • Implementação de novos sistemas com configuração uniforme.
  • Atualização dos sistemas e atualização dos pacotes de segurança e software.
  • Incorporando novos recursos e adicionando recursos hábeis.
  • Personalização de configurações para garantir a disponibilidade de fontes de dados.
  • Otimizando os recursos disponíveis e minimizando o custo.
  • Simplificar as funções e permitir que a equipe se concentre nas questões centrais e produtivas.
  • Ter uma visão panorâmica da infraestrutura disponível.

Ansible

Ansible é uma plataforma de automação de TI radicalmente simples que torna seus aplicativos e sistemas mais fáceis de implantar. Evite escrever scripts ou código personalizado para implantar e atualizar seus aplicativos - automatize em uma linguagem que se aproxime do inglês simples, usando SSH, sem agentes para instalar em sistemas remotos.

O primário features of Ansible são os seguintes -

  • Simples e fácil de aprender
  • Escrito em Python
  • Agentless
  • Playbooks baseados em YAML
  • Galáxia Ansible

SaltStack

SaltStack é usado para configuração baseada em dados. É uma nova abordagem de gerenciamento de infraestrutura baseada em barramento de comunicação dinâmico. Ele é usado para orquestração baseada em dados, execução remota para qualquer infraestrutura e gerenciamento de configuração para qualquer pilha de aplicativos.

Tecido

Fabric é uma linguagem de programação baseada em Python, que é desenvolvida como uma API de Python que precisa ser importada em código Python para configurar e gerenciar uma infraestrutura.

Chef trabalha em um modelo de servidor cliente de três camadas, em que as unidades de trabalho, como livros de receitas, são desenvolvidas na estação de trabalho Chef. A partir dos utilitários de linha de comando, como o knife, eles são carregados no servidor Chef e todos os nós que estão presentes na arquitetura são registrados no servidor Chef.

Para colocar a infraestrutura do Chef em funcionamento, precisamos configurar várias coisas em sequência.

Na configuração acima, temos os seguintes componentes.

Chef Workstation

Este é o local onde todas as configurações são desenvolvidas. A estação de trabalho Chef está instalada na máquina local. A estrutura de configuração detalhada é discutida nos capítulos posteriores deste tutorial.

Chef Server

Isso funciona como uma unidade de trabalho centralizada da configuração do Chef, onde todos os arquivos de configuração são carregados após o desenvolvimento. Existem diferentes tipos de servidor Chef, alguns são hospedados no servidor Chef enquanto outros são integrados.

Nós do Chef

Eles são as máquinas reais que serão gerenciadas pelo servidor Chef. Todos os nós podem ter diferentes tipos de configuração conforme a necessidade. O cliente Chef é o principal componente de todos os nós, o que ajuda a configurar a comunicação entre o servidor Chef e o nó Chef. Os outros componentes do nó Chef é Ohai, que ajuda a obter o estado atual de qualquer nó em um determinado ponto do tempo.

Usar o sistema de controle de versão é uma parte fundamental da automação da infraestrutura. Existem vários tipos de sistema de controle de versão, como SVN, CVS e GIT. Devido à popularidade do GIT entre a comunidade Chef, usaremos a configuração GIT.

Note - Não pense em construir uma infraestrutura como um código sem um sistema de controle de versão.

No Windows

Step 1- Baixe o instalador do Windows em www.git-scm.org e siga as etapas de instalação.

Step 2 - Inscreva-se em um repositório central no GitHub.

Step 3- Faça upload da chave ssh para a conta GitHub, para que se possa interagir com ela facilmente. Para obter detalhes sobre a chave SSH, visite o seguinte linkhttps://help.github.com/articles/generatingssh-keys.

Step 4 - Por fim, crie um repo na conta do github visitando https://github.com/new com o nome de chef-repo.

Antes de realmente começar a escrever um livro de receitas, pode-se configurar um repositório GIT inicial na caixa de desenvolvimento e clonar o repositório vazio fornecido pelo Opscode.

Step 1 - Baixe a estrutura vazia do repositório Opscode Chef.

$ wget https://github.com/opscode/chef-repo/tarball/master

Step 2 - Extraia a bola de piche.

$ tar –xvf master

Step 3 - Renomeie o diretório.

$ mv opscode-chef-repo-2c42c6a/ chef-repo

Step 4 - Altere o diretório de trabalho atual para chef repo.

$ cd chef-repo

Step 5 - Inicialize um novo get repo.

$ git init.

Step 6 - Conecte-se ao seu repo no hub git.

$ git remote add origin [email protected]:vipin022/chef-

Step 7 - Envie o repositório local para o github.

$ git add. $ git commit –m “empty repo structure added” 
$ git push –u origin maste

Ao usar o procedimento acima, você obterá um repositório de chef vazio no lugar. Você pode então começar a trabalhar no desenvolvimento de receitas e livros de receitas. Uma vez feito isso, você pode enviar as alterações para o GitHub.

O Chef segue o conceito de arquitetura cliente-servidor, portanto, para começar a trabalhar com o Chef, é necessário configurar o Chef na estação de trabalho e desenvolver a configuração localmente. Posteriormente, ele pode ser carregado no servidor Chef para fazê-los funcionar nos nós Chef, que precisam ser configurados.

O Opscode fornece uma versão totalmente empacotada, que não tem nenhum pré-requisito externo. Este Chef totalmente embalado é chamado deomnibus installer.

Em máquina Windows

Step 1 - Baixe o arquivo de configuração .msi do chefDK na máquina.

Step 2 - Siga as etapas de instalação e instale-o no local de destino.

A configuração será semelhante à mostrada na imagem a seguir.

Variável de caminho ChefDK

$ echo $PATH 
/c/opscode/chef/bin:/c/opscode/chefdk/bin:

Em máquina Linux

Para configurar na máquina Linux, primeiro precisamos obter o curl na máquina.

Step 1 - Depois que o curl estiver instalado na máquina, precisamos instalar o Chef na estação de trabalho usando o instalador Omnibus Chef do Opscode.

$ curl –L https://www.opscode.com/chef/install.sh | sudo bash

Step 2 - Instale o Ruby na máquina.

Step 3 - Adicione Ruby à variável de caminho.

$ echo ‘export PATH = ”/opt/chef/embedded/bin:$PATH”’ ≫ ~/.bash_profile && 
source ~/.bash_profile

O Omnibus Chef instalará Ruby e todas as joias Ruby necessárias em /opt/chef/embedded adicionando /opt/chef/embedded/bin diretório para o arquivo .bash_profile.

Se o Ruby já estiver instalado, instale a gem Chef Ruby na máquina executando o seguinte comando.

$ gem install chef

Para fazer o nó Chef se comunicar com o servidor Chef, você precisa configurar o cliente Chef no nó.

Cliente Chef

Este é um dos principais componentes do nó Chef, que recupera os livros de receitas do servidor Chef e os executa no nó. Ele também é conhecido como provisionador Chef.

Aqui, usaremos o Vagrant para gerenciar VM. O Vagrant também pode ser configurado com o provisionador, como script Shell, Chef e Puppet para colocar a VM em um estado desejado. Em nosso caso, usaremos o Vagrant para gerenciar VMs usando o VirtualBox e o cliente Chef como provisionador.

Step 1 - Baixe e instale o VirtualBox de https://www.virtualbox.org/wiki/downlod

Step 2 - Baixe e instale o Vagrant em http://downloads.vagrantup.com

Step 3 - Instale o plugin Vagrant Omnibus para permitir que o Vagrant instale o cliente Chef na VM.

$ vagrant plugin install vagrant-omnibus

Criação e inicialização virtual

Step 1- Podemos baixar a caixa do Vagrant necessária do repositório Opscode vagrant. Baixe a caixa opscode-ubuntu-12.04 no seguinte URLhttps://opscode-vmbento.s3.amazonaws.com/vagrant/opscode_ubuntu-12.04_provisionerless.box

Step 2 - Assim que tiver o arquivo Vagrant, baixe o caminho que você precisa para editar o arquivo Vagrant.

vipin@laptop:~/chef-repo $ subl Vagrantfile 
Vagrant.configure("2") do |config| 
   config.vm.box = "opscode-ubuntu-12.04" 
   config.vm.box_url = https://opscode-vm-bento.s3.amazonaws.com/ 
   vagrant/opscode_ubuntu-12.04_provisionerless.box 
   config.omnibus.chef_version = :latest  
   config.vm.provision :chef_client do |chef| 
      chef.provisioning_path = "/etc/chef" 
      chef.chef_server_url = "https://api.opscode.com/ 
      organizations/<YOUR_ORG>" 
      chef.validation_key_path = "/.chef/<YOUR_ORG>-validator.pem"
      chef.validation_client_name = "<YOUR_ORG>-validator" 
      chef.node_name = "server" 
   end 
end

No programa acima, você precisa atualizar o nome <YOUR_ORG> com o nome da organização correto ou obrigatório.

Step 3- O próximo passo após a configuração é levantar a caixa do vagrant. Para isso, você precisa ir até o local onde a caixa do Vagrant está localizada e executar o seguinte comando.

$ vagrant up

Step 4 - Assim que a máquina estiver ligada, você pode fazer login nela usando o seguinte comando.

$ vagrant ssh

No comando acima, vagrantfile é escrito em Ruby Domain Specific Language (DSL) para configurar a máquina virtual vagrant.

No arquivo vagrant, temos o objeto config. O Vagrant usará este objeto de configuração para configurar a VM.

Vagrant.configure("2") do |config| 
……. 
End

Dentro do bloco de configuração, você dirá ao vagrant qual imagem VM usar, para inicializar o nó.

config.vm.box = "opscode-ubuntu-12.04" 
config.vm.box_url = https://opscode-vm-bento.s3.amazonaws.com/ 
   vagrant/opscode_ubuntu-12.04_provisionerless.box

Na próxima etapa, você dirá ao Vagrant para baixar o plugin omnibus.

config.omnibus.chef_version = :latest

Depois de selecionar a caixa VM para inicializar, configure como provisionar a caixa usando o Chef.

config.vm.provision :chef_client do |chef| 
….. 
End

Dentro disso, você precisa configurar instruções sobre como conectar o nó virtual ao servidor Chef. Você precisa dizer ao Vagrant onde você precisa armazenar todas as coisas do Chef no nó.

chef.provisioning_path = "/etc/chef"

Test Kitchen é a estrutura de teste integrada do Chef. Ele permite escrever receitas de teste, que serão executadas nas VMs assim que forem instanciadas e convergidas usando o livro de receitas. As receitas de teste são executadas nessa VM e podem verificar se tudo funciona conforme o esperado.

ChefSpecé algo que apenas simula uma corrida do Chef. O teste de cozinha inicializa o nó real e executa o Chef nele.

Step 1 - Instale o Ruby gem de cozinha de teste e o gem vagrant de cozinha de teste para permitir que a cozinha de teste use o vagrant para o teste de rotação

$ gem install kitchen 
$ gem install kitchen-vagrant

Step 2- Configure a cozinha de teste. Isso pode ser feito criando.kitchen.yml no diretório do livro de receitas.

driver_plugin: vagrant 
driver_config: 
   require_chef_omnibus: true 
platforms: 
   - name: ubuntu-12.04 
   driver_config: 
      box: opscode-ubuntu-12.04 
      box_url: https://opscode-vm.s3.amazonaws.com/vagrant/opscode_ 
      ubuntu-12.04_provisionerless.box 
suites: 
   - name: default 
run_list: 
   - recipe[minitest-handler] 
   - recipe[my_cookbook_test] 
attributes: { my_cookbook: { greeting: 'Ohai, Minitest!'} }

No código acima, uma parte define que o vagrant precisa girar as VMs e define que você deseja que o Omnibus instale o Chef no nó de destino.

A segunda parte define qual plataforma você deseja testar os livros de receitas. O Vagrant sempre criará e destruirá novas instâncias. Você não precisa se preocupar com os efeitos colaterais das VMs vagrant que você cria usando o arquivo Vagrant.

A cozinha de teste pode ser considerada um ambiente temporário que ajuda a executar e testar livros de receitas em um ambiente temporário semelhante à produção. Com a cozinha de teste ativada, pode-se ter certeza de que determinado trecho de código está funcionando, antes de realmente ser implantado no ambiente de teste, pré-produção e produção. Esse recurso de cozinha de teste é seguido por muitas organizações como um conjunto antes de colocar os livros de receitas em um ambiente de trabalho real.

Teste de fluxo de trabalho da cozinha

A seguir estão as etapas envolvidas no fluxo de trabalho da cozinha de teste.

Criando um livro de receitas usando o Chef

Use o seguinte código para criar um livro de receitas.

$ chef generate cookbook motd_rhel 
Installing Cookbook Gems: 

Compiling Cookbooks... 
Recipe: code_generator::cookbook
   * directory[C:/chef/cookbooks/motd_rhel] action create
      - create new directory C:/chef/cookbooks/motd_rhel
   
   * template[C:/chef/cookbooks/motd_rhel/metadata.rb] action create_if_missing
      - create new file C:/chef/cookbooks/motd_rhel/metadata.rb
      - update content in file C:/chef/cookbooks/motd_rhel/metadata.rb from none to 
      d6fcc2 (diff output suppressed by config)
   
   * template[C:/chef/cookbooks/motd_rhel/README.md] action create_if_missing
      - create new file C:/chef/cookbooks/motd_rhel/README.md
      - update content in file C:/chef/cookbooks/motd_rhel/README.md from none to 50deab
         (diff output suppressed by config)
   
   * cookbook_file[C:/chef/cookbooks/motd_rhel/chefignore] action create
      - create new file C:/chef/cookbooks/motd_rhel/chefignore
      - update content in file C:/chef/cookbooks/motd_rhel/chefignore from none to 15fac5
         (diff output suppressed by config)
   
   * cookbook_file[C:/chef/cookbooks/motd_rhel/Berksfile] action create_if_missing
      - create new file C:/chef/cookbooks/motd_rhel/Berksfile
      - update content in file C:/chef/cookbooks/motd_rhel/Berksfile from none to 9f08dc
         (diff output suppressed by config)
   
   * template[C:/chef/cookbooks/motd_rhel/.kitchen.yml] action create_if_missing
      - create new file C:/chef/cookbooks/motd_rhel/.kitchen.yml
      - update content in file C:/chef/cookbooks/motd_rhel/.kitchen.yml
         from none to 49b92b (diff output suppressed by config)
   
   * directory[C:/chef/cookbooks/motd_rhel/test/integration/default/serverspec]
      action create 
      - create new directory 
         C:/chef/cookbooks/motd_rhel/test/integration/default/serverspec
   
   * directory[C:/chef/cookbooks/motd_rhel/test/integration/helpers/serverspec]
      action create 
      - create new directory 
         C:/chef/cookbooks/motd_rhel/test/integration/helpers/serverspec
   
   * cookbook_file
      [C:/chef/cookbooks/motd_rhel/test/integration/helpers/serverspec/spec_helper.rb]
      action create_if_missing
      - create new file 
         C:/chef/cookbooks/motd_rhel/test/integration/helpers/serverspec/spec_helper.rb
      - update content in file
         C:/chef/cookbooks/motd_rhel/test/integration/helpers/serverspec/spec_helper.rb
            from none to d85df4 (diff output suppressed by config)
   
   * template
      [C:/chef/cookbooks/motd_rhel/test/integration/default/serverspec/defaul t_spec.rb]
      action create_if_missing
      - create new file
         C:/chef/cookbooks/motd_rhel/test/integration/default/serverspec/default_spec.rb
      - update content in file
         C:/chef/cookbooks/motd_rhel/test/integration/default/serverspec/default_spec.rb
            from none to 3fbdbd (diff output suppressed by config)
   
   * directory[C:/chef/cookbooks/motd_rhel/spec/unit/recipes] action create
      - create new directory C:/chef/cookbooks/motd_rhel/spec/unit/recipes
   
   * cookbook_file
      [C:/chef/cookbooks/motd_rhel/spec/spec_helper.rb] action create_if_missing
      - create new file C:/chef/cookbooks/motd_rhel/spec/spec_helper.rb
      - update content in file
         C:/chef/cookbooks/motd_rhel/spec/spec_helper.rb from none to 587075
            (diff output suppressed by config)
   
   * template
      [C:/chef/cookbooks/motd_rhel/spec/unit/recipes/default_spec.rb]
      action create_if_missing
      - create new file C:/chef/cookbooks/motd_rhel/spec/unit/recipes/default_spec.rb
      - update content in file
         C:/chef/cookbooks/motd_rhel/spec/unit/recipes/default_spec.rb
            from none to ff3b17 (diff output suppressed by config)
   
   * directory[C:/chef/cookbooks/motd_rhel/recipes] action create
      - create new directory C:/chef/cookbooks/motd_rhel/recipes
   
   * template[C:/chef/cookbooks/motd_rhel/recipes/default.rb] action create_if_missing
      - create new file C:/chef/cookbooks/motd_rhel/recipes/default.rb
      - update content in file
         C:/chef/cookbooks/motd_rhel/recipes/default.rb from none to c4b029
            (diff output suppressed by config) 
   
   * execute[initialize-git] action run 
      - execute git init . 
   
   * cookbook_file[C:/chef/cookbooks/motd_rhel/.gitignore] action create
      - create new file C:/chef/cookbooks/motd_rhel/.gitignore
      - update content in file C:/chef/cookbooks/motd_rhel/.gitignore from none to 33d469
         (diff output suppressed by config)
   
   * execute[git-add-new-files] action run
      - execute git add .
   
   * execute[git-commit-new-files] action run 
      - execute git commit -m "Add generated cookbook content"

A seguir está a Estrutura do Livro de Receitas Criada como uma saída do código acima.

Arquivo de configuração de cozinha de teste

arquivo .kitchen.yaml

driver: 
   name: vagrant 
provisioner: 
   name: chef_zero 
# verifier: 
# name: inspec 
# format: doc 
platforms: 
   - name: ubuntu-14.04 
suites: 
   - name: default 
   run_list: 
      - recipe[motd_rhel::default] 
   attributes:

Drivers - Especifica o software que gerencia a máquina.

Provisioner- Fornece especificações sobre como o Chef é executado. Estamos usando chef_zero porque ele permite simular um ambiente de servidor Chef na máquina local. Isso permite trabalhar com atributos de nó e especificações do servidor Chef.

Platform - Isso especifica o sistema operacional de destino.

Suites- Define o que se quer aplicar no ambiente virtual. Aqui, você define múltiplas definições. É o local onde você define a lista de execução, que especifica qual receita executar e em que sequência precisamos executar.

Executando os Comandos em Sequência

Lista de cozinha

$ kitchen list 
Instance  Driver  Provisioner Verifier   Transport Last Action 
ubuntu-1404 Vagrant ChefZero   Busser       Ssh   <Not Created>

Cozinha Criar

$ kitchen create
-----> Starting Kitchen (v1.4.2)
-----> Creating <default-centos-72>...
      Bringing machine 'default' up with 'virtualbox' provider...
      ==> default: Box 'opscode-centos-7.2' could not be found.
         Attempting to find and install...
      default: Box Provider: virtualbox
      default: Box Version: >= 0
      ==> default: Box file was not detected as metadata. Adding it directly...
         ==> default: Adding box 'opscode-centos-7.2' (v0) for provider: virtualbox
         default: Downloading:
            https://opscode-vmbento.s3.amazonaws.com/vagrant/virtualbox/
            opscode_centos-7.1_chefprovisionerless.box[...]
         Vagrant instance <default-centos-72> created.
         Finished creating <default-centos-72> (3m12.01s).
         -----> Kitchen is finished. (3m12.60s)

Cozinha Converge

$ kitchen converge 
-----> Converging <default-centos-72>...        
      Preparing files for transfer        
      Preparing dna.json        
      Resolving cookbook dependencies with Berkshelf 4.0.1...
      Removing non-cookbook files before transfer       
      Preparing validation.pem        
      Preparing client.rb 
-----> Chef Omnibus   installation detected (install only if missing)        
      Transferring files to <default-centos-72>       
      Starting Chef Client, version 12.6.0        
      resolving cookbooks for run list: ["motd_rhel::default"]
      Synchronizing Cookbooks: - motd_rhel (0.1.0)       
      Compiling Cookbooks...       Converging 1 resources        
      Recipe: motd_rhel::default        (up to date)         
      Running handlers:       Running handlers complete       
      Chef Client finished, 0/1 resources updated in 01 seconds        
      Finished converging <default-centos-72> (0m3.57s). 
      -----> Kitchen is finished. (0m4.55s)

Configuração de teste

O login da cozinha é usado para testar se a VM de teste está provisionada corretamente.

$ kitchen login 
Last login: Thu Jan 30 19:02:14 2017 from 10.0.2.2 
hostname:  default-centos-72 
fqdn:      default-centos-72 
memory:    244180kBcpu count: 1

Finalmente saia

$ exit 
Logout 
Connection to 127.0.0.1 closed.

Destruindo configuração

$ Kitchen destroy 
-----> Starting Kitchen (v1.4.2) 
-----> Destroying <default-centos-72>...       
   ==> default: Forcing shutdown of VM...        
   ==> default: Destroying VM and associated drives...        
   Vagrant instance <default-centos-72> destroyed.        
   Finished destroying <default-centos-72> (0m4.94s). 
-----> Kitchen is finished. (0m5.93s)

Knife é a ferramenta de linha de comando do Chef para interagir com o servidor Chef. Ele é usado para enviar livros de receitas e gerenciar outros aspectos do Chef. Ele fornece uma interface entre o chefDK (Repo) na máquina local e o servidor Chef. Ajuda na gestão -

  • Nós Chef
  • Cookbook
  • Recipe
  • Environments
  • Recursos de nuvem
  • Provisionamento em nuvem
  • Instalação no cliente Chef em nós Chef

O Knife fornece um conjunto de comandos para gerenciar a infraestrutura do Chef.

Comandos de bootstrap

  • faca bootstrap [SSH_USER @] FQDN (opções)

Comandos do cliente

  • faca cliente em massa excluir REGEX (opções)
  • faca cliente criar CLIENTNAME (opções)
  • faca cliente excluir CLIENTE (opções)
  • faca cliente editar CLIENTE (opções)
  • Uso: C: / opscode / chef / bin / faca (opções)
  • faca da chave do cliente excluir CLIENT KEYNAME (opções)
  • faca edição da chave do cliente CLIENT KEYNAME (opções)
  • faca lista de chaves do cliente CLIENTE (opções)
  • Knife a chave do cliente mostra o CLIENT KEYNAME (opções)
  • lista de clientes de faca (opções)
  • cliente do faca registre novamente CLIENTE (opções)
  • faca cliente mostrar CLIENTE (opções)

Configurar comandos

  • faca configurar (opções)
  • faca configurar cliente DIRETÓRIO

Comandos do livro de receitas

  • faca livro de receitas excluir em massa REGEX (opções)
  • faca livro de receitas criar COOKBOOK (opções)
  • faca livro de receitas excluir VERSÃO DO COOKBOOK (opções)
  • Baixar livro de receitas da faca COOKBOOK [VERSÃO] (opções)
  • lista do livro de receitas da faca (opções)
  • Metadados do livro de receitas da faca COOKBOOK (opções)
  • Metadados do livro de receitas da faca de FILE (opções)
  • faca livro de receitas mostrar COOKBOOK [VERSÃO] [PARTE] [NOME DO ARQUIVO] (opções)
  • teste de livro de receitas de faca [COOKBOOKS ...] (opções)
  • upload do livro de receitas da faca [COOKBOOKS ...] (opções)

Comandos do site do livro de receitas

  • download do site do livro de receitas da faca COOKBOOK [VERSÃO] (opções)
  • faca livro de receitas site instalar COOKBOOK [VERSÃO] (opções)
  • lista de sites de livro de receitas de faca (opções)
  • pesquisa de site de livro de receitas de faca QUERY (opções)
  • faca livro de receitas site compartilhar COOKBOOK [CATEGORY] (opções)
  • site do livro de receitas da faca mostrar COOKBOOK [VERSÃO] (opções)
  • site de livro de receitas de faca unshare COOKBOOK

Comandos do Data Bag

  • saco de dados de faca criar SACO [ITEM] (opções)
  • saco de dados de faca excluir SACO [ITEM] (opções)
  • saco de dados de faca editar ITEM DE SACO (opções)
  • saco de dados de faca do arquivo BAG FILE | FOLDER [FILE | FOLDER ..] (opções)
  • lista do saco de dados da faca (opções)
  • saco de dados de faca mostrar SACO [ITEM] (opções)

Comandos de Ambiente

  • ambiente de faca comparar [AMBIENTE ..] (opções)
  • ambiente de faca criar AMBIENTE (opções)
  • faca ambiente delete AMBIENTE (opções)
  • faca ambiente editar AMBIENTE (opções)
  • ambiente de faca do arquivo FILE [FILE ..] (opções)
  • lista de ambiente de faca (opções)
  • faca ambiente mostrar AMBIENTE (opções)

Comandos Executivos

  • faca exec [SCRIPT] (opções)

Comandos de ajuda

  • ajuda da faca [lista | TÓPICO]

Comandos de Índice

  • reconstrução de índice de faca (opções)

Comandos de Nó

  • nó de faca em massa excluir REGEX (opções)
  • Nó de faca criar NODE (opções)
  • nó de faca delete NODE (opções)
  • NÓ de faca editar NÓ (opções)
  • conjunto de ambiente de nó de faca NODE ENVIRONMENT
  • nó de faca do arquivo FILE (opções)
  • lista de nós de faca (opções)
  • faca nó run_list add [NODE] [ENTRY [, ENTRY]] (opções)
  • Nó de faca run_list remover [NODE] [ENTRY [, ENTRY]] (opções)
  • Nó de faca run_list set NODE ENTRIES (opções)
  • nó de faca mostrar NODE (opções)

Comandos OSC

  • faca osc_user criar USUÁRIO (opções)
  • faca osc_user delete USER (opções)
  • faca osc_user editar USUÁRIO (opções)
  • lista osc_user da faca (opções)
  • faca osc_user registre novamente USER (opções)
  • faca osc_user mostrar USUÁRIO (opções)

Comandos baseados em caminho

  • faca excluir [PATTERN1 ... PATTERNn]
  • faca deps PATTERN1 [PATTERNn]
  • faca diff PADRÕES
  • faca download PADRÕES
  • faca editar [PATTERN1 ... PATTERNn]
  • lista de facas [-dfR1p] [PATTERN1 ... PATTERNn]
  • faca mostrar [PATTERN1 ... PATTERNn]
  • faca de upload PADRÕES
  • faca xargs [COMANDO]

Comandos Brutos

  • faca bruta REQUEST_PATH

Comandos de receita

  • lista de receitas de faca [PATTERN]

Comandos de função

  • função da faca em massa excluir REGEX (opções)
  • função de faca criar ROLE (opções)
  • papel da faca apagar ROLE (opções)
  • papel da faca editar ROLE (opções)
  • papel da faca env_run_list adicionar [ROLE] [AMBIENTE] [ENTRADA [, ENTRADA]] (opções)
  • papel da faca env_run_list limpar [ROLE] [AMBIENTE]
  • papel da faca env_run_list remover [ROLE] [AMBIENTE] [ENTRIES]
  • papel da faca env_run_list substituir [ROLE] [AMBIENTE] [OLD_ENTRY] [NEW_ENTRY]
  • papel da faca env_run_list definido [ROLE] [AMBIENTE] [ENTRIES]
  • função de faca do arquivo FILE [FILE ..] (opções)
  • lista de funções da faca (opções)
  • faca função run_list add [ROLE] [ENTRY [, ENTRY]] (opções)
  • função da faca run_list limpar [ROLE]
  • papel da faca run_list remover [ROLE] [ENTRY]
  • função da faca run_list substituir [ROLE] [OLD_ENTRY] [NEW_ENTRY]
  • função da faca run_list definida [ROLE] [ENTRIES]
  • papel da faca mostrar ROLE (opções)

Comandos de serviço

  • faca de servir (opções)

Comandos SSH

  • faca ssh COMANDO DE CONSULTA (opções)

Comandos SSL

  • verificação SSL da faca [URL] (opções)
  • faca ssl buscar [URL] (opções)

Comandos de status

  • status da faca QUERY (opções)

Comandos de Tag

  • tag de faca criar TAG DE NÓ ...
  • tag de faca excluir TAG DE NÓ ...
  • lista de tags de faca NODE

Comandos do usuário

  • usuário do faca criar USERNAME DISPLAY_NAME FIRST_NAME LAST_NAME EMAIL PASSWORD (opções)
  • faca usuário deletar USUÁRIO (opções)
  • faca edição do usuário USUÁRIO (opções)
  • faca de usuário chave criar USUÁRIO (opções)
  • faca de usuário chave deletar USER KEYNAME (opções)
  • faca edição da chave do usuário USER KEYNAME (opções)
  • faca lista de chaves do usuário USUÁRIO (opções)
  • Knife a chave do usuário mostra o USER KEYNAME (opções)
  • lista de usuários de faca (opções)
  • usuário de faca registre novamente USUÁRIO (opções)
  • usuário faca mostrar USUÁRIO (opções)

Configuração da faca

A fim de configurar a faca, é necessário mover para .chef diretório e criar um knife.rbdentro do chef repo, que informa a faca sobre os detalhes da configuração. Isso terá alguns detalhes.

current_dir = File.dirname(__FILE__) 
log_level                :info 
log_location             STDOUT 
node_name                'node_name' 
client_key               "#{current_dir}/USER.pem" 
validation_client_name   'ORG_NAME-validator' 
validation_key           "#{current_dir}/ORGANIZATION-validator.pem" 
chef_server_url          'https://api.chef.io/organizations/ORG_NAME' 
cache_type               'BasicFile' 
cache_options( :path =>  "#{ENV['HOME']}/.chef/checksums" ) 
cookbook_path            ["#{current_dir}/../cookbooks"]

No código acima, estamos usando o servidor Chef hospedado, que usa as duas chaves a seguir.

validation_client_name   'ORG_NAME-validator' 
validation_key           "#{current_dir}/ORGANIZATION-validator.pem"

Aqui, knife.rb diz a knife qual organização usar e onde encontrar a chave privada. Diz ao Knife onde encontrar a chave privada do usuário.

client_key               "#{current_dir}/USER.pem"

A seguinte linha de código diz ao Knife que estamos usando o servidor hospedado.

chef_server_url        'https://api.chef.io/organizations/ORG_NAME'

Usando o arquivo knife.rb, a faca validadora agora pode se conectar ao Opscode hospedado de sua organização.

Chef-Solo é uma ferramenta de código aberto que roda localmente e permite provisionar máquinas convidadas usando livros de receitas do Chef sem a complicação de qualquer configuração de cliente e servidor Chef. Isso ajuda a executar livros de receitas em um servidor criado por você mesmo.

Antes de executar o Chef-Solo na máquina local, é necessário instalar os dois arquivos a seguir na máquina local.

  • Solo.rb - Este arquivo informa ao Chef sobre onde encontrar livros de receitas, funções e pacotes de dados.

  • Node.json - Este arquivo define a lista de execução e qualquer atributo específico do nó, se necessário.

Configuração solo.rb

A seguir estão as etapas para configurar solo.rb.

Step 1 - Crie um arquivo solo.rb dentro do chef repo.

current_dir       = File.expand_path(File.dirname(__FILE__)) 
file_cache_path   "#{current_dir}" 
cookbook_path     "#{current_dir}/cookbooks" 
role_path         "#{current_dir}/roles" 
data_bag_path     "#{current_dir}/data_bags"

Step 2 - Adicione o arquivo ao git repo.

$ git add solo.rb

Step 3 - Crie um arquivo node.json dentro do chef repo com o seguinte conteúdo.

{ 
   "run_list": [ "recipe[ntp]" ] 
}

Step 4 - Pegue o livro de receitas ntp dentro do repositório do chef usando uma faca.

vipin@laptop:~/chef-repo $ knife cookbook site install ntp 
Installing ntp to /Users/mma/work/chef-repo/cookbooks 
…TRUNCATED OUTPUT… 
Cookbook ntp version 1.3.0 successfully installed

Step 5 - Adicione o arquivo node.json ao Git.

$ git add node.json

Step 6 - Confirme e envie os arquivos para o git repo.

vipin@laptop:~/chef-repo $ git commit -m "initial setup for Chef Solo" 
vipin@laptop:~/chef-repo $ git push 
Counting objects: 4, done. 
Delta compression using up to 4 threads. 
...TRUNCATED OUTPUT... 
To [email protected]:mmarschall/chef-repo.git 
b930647..5bcfab6 master -> master

Executando o livro de receitas no nó

Step 1 - Faça login no nó onde se deseja provisionar o Chef-Solo.

Step 2 - Clone o repositório Chef na máquina.

$ git clone $URL_PATH

Step 3 - cd para o chef repo.

$ cd chef-repo

Finalmente, execute o Chef-Solo para convergir o nó -

$ sudo chef-solo -c solo.rb -j node.json 
[2017-20-08T22:54:13+01:00] INFO: *** Chef 11.0.0 *** 
[2017-20-08T22:54:13+01:00] INFO: Setting the run_list to 
["recipe[ntp]"] from JSON 
...TRUNCATED OUTPUT... 
[2012-12-08T22:54:16+01:00] INFO: Chef Run complete in 2.388374 
seconds 
[2012-12-08T22:54:16+01:00] INFO: Running report handlers

solo.rb configura Chef-Solo para procurar seus livros de receitas, funções e pacotes de dados dentro do diretório atual: o repositório Chef.

Chef-Soloobtém sua configuração de nó de um arquivo JSON. Em nosso exemplo, o chamamos de node.json. Se você for gerenciar vários servidores, precisará de um arquivo separado para cada nó. Em seguida, Chef-Solo apenas executa uma execução de Chef com base nos dados de configuração encontrados em solo.rb e node.json.

Os livros de receitas são unidades de trabalho fundamentais do Chef, que consistem em todos os detalhes relativos às unidades de trabalho, tendo a capacidade de modificar a configuração e o estado de qualquer sistema configurado como um nó na infraestrutura do Chef. Os livros de receitas podem realizar várias tarefas. Os livros de receitas contêm valores sobre o estado desejado do nó. Isso é obtido no Chef usando as bibliotecas externas desejadas.

Principais componentes de um livro de receitas

  • Recipes
  • Metadata
  • Attributes
  • Resources
  • Templates
  • Libraries
  • Qualquer outra coisa que ajude a criar um sistema

Criando um livro de receitas

Existem duas maneiras de criar dinamicamente um livro de receitas.

  • Usando o comando do chef
  • Usando o utilitário de faca

Usando o Comando Chef

Para criar um livro de receitas vazio usando o comando Chef, execute o seguinte comando.

C:\Users\vipinkumarm>chef generate cookbook <Cookbook Name> 
C:\Users\vipinkumarm>chef generate cookbook VTest
Installing Cookbook Gems:

Compiling Cookbooks...
Recipe: code_generator::cookbook
   * directory[C:/Users/vipinkumarm/VTest] action create
      - create new directory C:/Users/vipinkumarm/VTest
   
   * template[C:/Users/vipinkumarm/VTest/metadata.rb] action create_if_missing
      - create new file C:/Users/vipinkumarm/VTest/metadata.rb
      - update content in file C:/Users/vipinkumarm/VTest/metadata.rb 
         from none to 4b9435 (diff output suppressed by config)

   * template[C:/Users/vipinkumarm/VTest/README.md] action create_if_missing
      - create new file C:/Users/vipinkumarm/VTest/README.md
      - update content in file C:/Users/vipinkumarm/VTest/README.md 
         from none to 482077 (diff output suppressed by config)

   * cookbook_file[C:/Users/vipinkumarm/VTest/chefignore] action create
      - create new file C:/Users/vipinkumarm/VTest/chefignore
      - update content in file C:/Users/vipinkumarm/VTest/chefignore 
         from none to 15fac5 (diff output suppressed by config)
   
   * cookbook_file[C:/Users/vipinkumarm/VTest/Berksfile] action create_if_missing
      - create new file C:/Users/vipinkumarm/VTest/Berksfile
      - update content in file C:/Users/vipinkumarm/VTest/Berksfile 
         from none to 9f08dc (diff output suppressed by config)

   * template[C:/Users/vipinkumarm/VTest/.kitchen.yml] action create_if_missing
      - create new file C:/Users/vipinkumarm/VTest/.kitchen.yml
      - update content in file C:/Users/vipinkumarm/VTest/.kitchen.yml 
         from none to 93c5bd (diff output suppressed by config)

   * directory[C:/Users/vipinkumarm/VTest/test/integration/default/serverspec]
      action create
      - create new directory
         C:/Users/vipinkumarm/VTest/test/integration/default/serverspec
   
   * directory[C:/Users/vipinkumarm/VTest/test/integration/helpers/serverspec]
      action create
      - create new directory
         C:/Users/vipinkumarm/VTest/test/integration/helpers/serverspec
   
   * cookbook_file
      [C:/Users/vipinkumarm/VTest/test/integration/helpers/serverspec/sp ec_helper.rb]
      action create_if_missing
      - create new file
         C:/Users/vipinkumarm/VTest/test/integration/helpers/serverspec/spec_helper.rb
      - update content in file
         C:/Users/vipinkumarm/VTest/test/integration/helpers/serverspec/spec_helper.rb
         from none to d85df4 (diff output suppressed by config)
   
   * template
      [C:/Users/vipinkumarm/VTest/test/integration/default/serverspec/default _spec.rb]
      action create_if_missing
      - create new file
         C:/Users/vipinkumarm/VTest/test/integration/default/serverspec/default_spec.rb
      - update content in file
         C:/Users/vipinkumarm/VTest/test/integration/default/serverspec/default_spec.rb
         from none to 758b94 (diff output suppressed by config)
   
   * directory[C:/Users/vipinkumarm/VTest/spec/unit/recipes] action create
      - create new directory C:/Users/vipinkumarm/VTest/spec/unit/recipes
   
   * cookbook_file[C:/Users/vipinkumarm/VTest/spec/spec_helper.rb]
      action create_if_missing
      - create new file C:/Users/vipinkumarm/VTest/spec/spec_helper.rb
      - update content in file C:/Users/vipinkumarm/VTest/spec/spec_helper.rb
         from none to 587075 (diff output suppressed by config)

   * template[C:/Users/vipinkumarm/VTest/spec/unit/recipes/default_spec.rb]
      action create_if_missing
      - create new file C:/Users/vipinkumarm/VTest/spec/unit/recipes/default_spec.rb
      - update content in file 
         C:/Users/vipinkumarm/VTest/spec/unit/recipes/default_spec.rb
         from none to 779503 (diff output suppressed by config)
      - create new file C:/Users/vipinkumarm/VTest/recipes/default.rb
      - update content in file C:/Users/vipinkumarm/VTest/recipes/default.rb
         from none to 8cc381 (diff output suppressed by config)

   * cookbook_file[C:/Users/vipinkumarm/VTest/.gitignore] action create
      - create new file C:/Users/vipinkumarm/VTest/.gitignore
      - update content in file C:/Users/vipinkumarm/VTest/.gitignore from none to 33d469
         (diff output suppressed by config)

A estrutura do livro de receitas com o nome VTest será criada no diretório e a seguir será a estrutura do mesmo.

Usando o utilitário de faca

Use o seguinte comando para criar um livro de receitas usando o utilitário de faca.

C:\Users\vipinkumarm\VTest>knife cookbook create VTest2 
WARNING: No knife configuration file found 
** Creating cookbook VTest2 in C:/chef/cookbooks 
** Creating README for cookbook: VTest2 
** Creating CHANGELOG for cookbook: VTest2 
** Creating metadata for cookbook: VTest2

A seguir está a estrutura do livro de receitas.

Os recursos de definição das dependências do livro de receitas ajudam no gerenciamento do livro de receitas. Este recurso é usado quando queremos usar a funcionalidade de um livro de receitas em outros livros de receitas.

Por exemplo, se alguém deseja compilar o código C, é necessário certificar-se de que todas as dependências necessárias para compilar estão instaladas. Para fazer isso, pode haver um livro de receitas separado que pode executar essa função.

Quando estamos usando o chef-server, precisamos conhecer essas dependências nos livros de receitas que devem ser desaceleradas no arquivo de metadados dos livros de receitas. Este arquivo está localizado no topo da estrutura de diretórios do livro de receitas. Ele fornece dicas para o servidor Chef que ajuda na implantação de livros de receitas no nó correto.

Recursos do arquivo metadata.rb

  • Localizado na parte superior da estrutura de diretórios do livro de receitas.

  • Compilado quando o livro de receitas é carregado no servidor Chef usando o comando de faca.

  • Compilado com o subcomando de metadados do livro de receitas da faca.

  • Criado automaticamente quando o comando de criação do livro de receitas da faca é executado.

Configuração de metadata.rb

A seguir está o conteúdo padrão de um arquivo de metadados.

As funções no Chef são uma forma lógica de agrupar nós. Casos típicos devem ter funções para servidores web, servidores de banco de dados e assim por diante. Pode-se definir uma lista de execução personalizada para todos os nós e substituir o valor do atributo nas funções.

Crie uma função

vipin@laptop:~/chef-repo $ subl roles/web_servers.rb 
name "web_servers" 
description "This role contains nodes, which act as web servers" 
run_list "recipe[ntp]" 
default_attributes 'ntp' => { 
   'ntpdate' => { 
      'disable' => true 
   } 
}

Depois de criar a função, precisamos fazer o upload para o servidor Chef.

Carregar função para Chef Server

vipin@laptop:~/chef-repo $ knife role from file web_servers.rb

Agora, precisamos atribuir uma função a um nó chamado servidor.

Atribuir uma função ao nó

vipin@laptop:~/chef-repo $ knife node edit server 
"run_list": [ 
   "role[web_servers]" 
] 
Saving updated run_list on node server

Execute o Chef-Client

user@server:~$ sudo chef-client 
...TRUNCATED OUTPUT... 
[2013-07-25T13:28:24+00:00] INFO: Run List is [role[web_servers]] 
[2013-07-25T13:28:24+00:00] INFO: Run List expands to [ntp] 
...TRUNCATED OUTPUT...

Como funciona

  • Defina uma função em um arquivo Ruby dentro da pasta de funções do repositório Chef.

  • Uma função consiste em um nome e um atributo de descrição.

  • Uma função consiste em uma lista de execução específica da função e configurações de atributos específicos da função.

  • Cada nó que tem uma função em sua lista de execução terá a lista de execução da função exata em sua própria.

  • Todas as receitas na lista de execução da função serão executadas no nó.

  • A função será carregada no servidor Chef usando a função de faca do comando de arquivo.

  • A função será adicionada à lista de execução do nó.

  • Executar o cliente Chef em um nó com a função em sua lista de execução executará todas as receitas listadas na função.

Chef ajuda a realizar a configuração específica do ambiente. É sempre uma boa ideia ter um ambiente separado para desenvolvimento, teste e produção.

Chef permite agrupar nós em ambientes separados para suportar um fluxo de desenvolvimento ordenado.

Criando um Ambiente

A criação do ambiente em tempo real pode ser feita usando o utilitário de faca. O comando a seguir abrirá um editor padrão do Shell, para que se possa modificar a definição do ambiente.

vipin@laptop:~/chef-repo $ knife environment create book { 
   "name": "book", 
   "description": "", 
   "cookbook_versions": { 
   }, 
   "json_class": "Chef::Environment", 
   "chef_type": "environment", 
   "default_attributes": { 
   }, 
   "override_attributes": { 
   } 
} 
Created book

Testando um ambiente criado

vipin@laptop:~/chef-repo $ knife environment list 
_default 
book

Nó de lista para todos os ambientes

vipin@laptop:~/chef-repo $ knife node list 
my_server

_ambiente padrão

Cada organização sempre iniciará com pelo menos um único ambiente denominado ambiente padrão, que está sempre disponível para o servidor Chef. Um ambiente padrão não pode ser modificado de forma alguma. Qualquer tipo de mudança só pode ser acomodado no ambiente personalizado que criamos.

Atributos de ambiente

Um atributo pode ser definido em um ambiente e, em seguida, usado para substituir as configurações padrão no nó. Quando a execução do cliente Chef ocorre, esses atributos são comparados com os atributos padrão que já estão presentes no nó. Quando os atributos de ambiente têm precedência sobre os atributos padrão, o cliente Chef aplicará essas configurações e valores quando a execução do cliente Chef ocorrer em cada nó.

Um atributo de ambiente só pode ser default_attribute ou override_attribute. Não pode ser um atributo normal. Pode-se usar os métodos default_attribute ou override_attribute.

Tipo de Atributo

Default - Um atributo padrão é sempre redefinido no início de cada execução do cliente Chef e tem a precedência de atributo mais baixa.

Override- Um atributo de substituição é sempre redefinido no início de cada execução do cliente Chef e tem uma precedência de atributo mais alta que o padrão, force_default e normal. Um atributo de substituição é mais frequentemente definido na receita, mas também pode ser especificado em um arquivo de atributo para uma função ou para um ambiente.

Ordem de aplicação de um atributo

Executar Chef-Client como daemon ajuda a saber o estado de todos os nós em qualquer ponto do tempo. Isso ajuda na execução do Chef-Client a qualquer momento.

Pré-requisitos

O nó deve ser registrado com o servidor Chef e deve estar executando Chef-Client sem qualquer erro.

Chef-Cliente no Modo Daemon

Inicie o Chef-Client no modo daemon, executando a cada 30 minutos.

user@server:~$ sudo chef-client -i 1800

No código acima, - i permite executar o Chef-Client no modo daemon no nó necessário e 1800 segundos definem que o Chef-Client daemon deve ser executado a cada 30 minutos.

Validando Daemon Run

Valide se o Chef-Client está sendo executado como um daemon.

user@server:~$ ps auxw | grep chef-client

O comando acima irá executar grep no processo daemon em execução do Chef-Client.

Outras maneiras

Em vez de executar Chef-Client como um daemon, podemos executar o mesmo como um cron job.

user@server:~$ subl /etc/cron.d/chef_client 
PATH=/usr/local/bin:/usr/bin:/bin 
# m h dom mon dow user command 
*/15 * * * * root chef-client -l warn | grep -v 'retrying [1234]/5 in'

O cron job acima será executado a cada 15 minutos.

Escrever livros de receitas do Chef é sempre difícil. Isso torna ainda mais difícil por causa do longo ciclo de feedback de enviá-los ao servidor Chef, provisionar uma VM vagrant, verificar como eles falharam lá, enxágue e repita. Seria mais fácil se pudéssemos tentar testar algumas peças ou receitas antes de fazer todo esse trabalho pesado de uma vez.

Chef vem com Chef-Shell, que é essencialmente uma sessão interativa de Ruby com Chef. No Chef-Shell, podemos criar -

  • Attributes
  • Escrever receitas
  • Inicializando execuções do Chef

Ele é usado para avaliar partes de receitas na hora, antes de enviá-las ao servidor do Chef e executar livros de receitas completos no nó.

Running Shell

Step 1 - Execute Chef-Shell em modo autônomo.

mma@laptop:~/chef-repo $ chef-shell 
loading configuration: none (standalone chef-shell session) 
Session type: standalone 
Loading...[2017-01-12T20:48:01+01:00] INFO: Run List is [] 
[2017-01-12T20:48:01+01:00] INFO: Run List expands to [] 
done. 
This is chef-shell, the Chef Shell. 
Chef Version: 11.0.0 
http://www.opscode.com/chef 
http://wiki.opscode.com/display/chef/Home 
run `help' for help, `exit' or ^D to quit. 
Ohai2u mma@laptop!  
chef >

Step 2 - Mude para o modo de atributo no Chef-Shell

  • chef > attributes_mode

Step 3 - Definir o valor do atributo.

  • chef:attributes > set[:title] = "Chef Cookbook"

    • "Livro de receitas do chef"

  • chef:attributes > quit

    • :attributes

  • chef >

Step 4 - Mude para o modo de receita.

  • chef > recipe_mode

Step 5 - Crie um recurso de arquivo.

chef:recipe > file "/tmp/book.txt" do 
chef:recipe > content node.title 
chef:recipe ?> end  

=> <file[/tmp/book.txt] @name: "/tmp/book.txt" @noop: nil @ 
before: nil @params: {} @provider: Chef::Provider::File @allowed_ 
actions: [:nothing, :create, :delete, :touch, :create_if_missing] 
@action: "create" @updated: false @updated_by_last_action: false 
@supports: {} @ignore_failure: false @retries: 0 @retry_delay: 
2 @source_line: "(irb#1):1:in `irb_binding'" @elapsed_time: 0 @ 
resource_name: :file @path: "/tmp/book.txt" @backup: 5 @diff: nil 
@cookbook_name: nil @recipe_name: nil @content: "Chef Cookbook">   

chef:recipe >

Step 6 - Comece a execução do Chef para criar o arquivo com o conteúdo fornecido.

  • chef:recipe > run_chef

[2017-01-12T21:07:49+01:00] INFO: Processing file[/tmp/book.txt] 
action create ((irb#1) line 1) 
--- /var/folders/1r/_35fx24d0y5g08qs131c33nw0000gn/T/cheftempfile20121212- 
11348-dwp1zs 2012-12-12 21:07:49.000000000 
+0100 
+++ /var/folders/1r/_35fx24d0y5g08qs131c33nw0000gn/T/chefdiff20121212- 
11348-hdzcp1 2012-12-12 21:07:49.000000000 +0100 
@@ -0,0 +1 @@ 
+Chef Cookbook 
\ No newline at end of file 
[2017-01-12T21:07:49+01:00] INFO: entered create 
[2017-01-12T21:07:49+01:00] INFO: file[/tmp/book.txt] created file 
/tmp/book.txt

Como funciona

  • Chef-Shell começa com uma sessão Interactive Ruby (IRB) aprimorada com alguns recursos específicos.

  • Oferece modos como attribute_mode e interativo_mode.

  • Ajuda a escrever comandos, que são escritos dentro de uma receita ou livro de receitas.

  • Ele executa tudo em um modo interativo.

Podemos executar Chef-Shell em três modos diferentes: Standalone mode, Client mode, e Solo mode.

  • Standalone mode- É o modo padrão. Nenhum livro de receitas foi carregado e a lista de execução está vazia.

  • Client mode - Aqui, o chef-shell atua como chef-cliente.

  • Solo mode - Aqui, o chef-shell atua como um cliente solo do chef.

No caso de o livro de receitas ser implantado diretamente e executado no servidor de produção, há grandes chances de que o livro de receitas seja interrompido na produção. A melhor maneira de evitar que isso aconteça é testando o livro de receitas no ambiente de configuração.

A seguir estão as etapas de teste.

Step 1 - Instale o livro de receitas usando o seguinte comando.

vipin@laptop:~/chef-repo $ knife cookbook site install <cookbook name>

Step 2 - Execute os comandos de teste do livro de receitas da faca no livro de receitas de trabalho.

vipin@laptop:~/chef-repo $ knife cookbook test VTest  
checking ntp 
Running syntax check on ntp 
Validating ruby files 
Validating templates

Step 3 - Quebre algo no livro de receitas e teste novamente.

vipin@laptop:~/chef-repo $ subl cookbooks/VTest/recipes/default.rb 
... 
[ node['ntp']['varlibdir'] 
node['ntp']['statsdir'] ].each do |ntpdir| 
   directory ntpdir do 
      owner node['ntp']['var_owner'] 
      group node['ntp']['var_group'] 
      mode 0755 
   end 
end

Step 4 - Execute o comando de teste de faca novamente.

vipin@laptop:~/chef-repo $ knife cookbook test ntp 
checking ntp 
Running syntax check on ntp 
Validating ruby files 
FATAL: Cookbook file recipes/default.rb has a ruby syntax error: 
FATAL: cookbooks/ntp/recipes/default.rb:25: syntax error, 
unexpected tIDENTIFIER, expecting ']' 
FATAL: node['ntp']['statsdir'] ].each do |ntpdir| 
FATAL: ^ 
FATAL: cookbooks/ntp/recipes/default.rb:25: syntax error, 
unexpected ']', expecting $end 
FATAL: node['ntp']['statsdir'] ].each do |ntpdir| 
FATAL:

Método de trabalho

O teste do livro de receitas do Knife executa uma verificação de sintaxe Ruby em todos os arquivos Ruby dentro do livro de receitas, bem como em todos os modelos ERB. Ele percorre arquivos Ruby e executa Ruby–ccontra cada um deles. Rubi–c verifica a sintaxe do script e fecha sem executá-lo.

Depois de passar por todos os arquivos Ruby, o teste do livro de receitas da faca passa por todos os modelos e tubos ERB, a versão redundante criada por –x através de Ruby –c.

Limitações

O teste do livro de receitas do Knife faz apenas uma verificação de sintaxe simples nos arquivos Ruby e modelos ERB. Podemos seguir em frente totalmente testados usando ChefSpec e cozinha de teste.

Escrever bons livros de receitas sem qualquer problema é uma tarefa bastante difícil. Mas existem maneiras que podem ajudar a identificar as armadilhas. É possível sinalizar no livro de receitas do Chef. Foodcritic é uma das melhores formas de arquivamento, que tenta identificar possíveis problemas com a lógica e o estilo dos livros de receitas.

Configuração da crítica alimentar

Step 1 - Adicione a gema Foodcritic.

vipin@laptop:~/chef-repo $ subl Gemfile 
source 'https://rubygems.org' 
gem 'foodcritic', '~>2.2.0'

Step 2 - Instale a gema.

vipin@laptop:~/chef-repo $ bundle install 
Fetching gem metadata from https://rubygems.org/ 
...TRUNCATED OUTPUT... 
Installing foodcritic (2.2.0)

Jóia do Crítico Alimentar

Step 1 - Execute Foodcritic no livro de receitas.

vipin@laptop:~/chef-repo $ foodcritic ./cookbooks/<Cookbook Name> 
FC002: Avoid string interpolation where not required: ./cookbooks/ 
mysql/attributes/server.rb:220 
...TRUNCATED OUTPUT... 
FC024: Consider adding platform equivalents: ./cookbooks/<Cookbook Name>/ 
recipes/server.rb:132

Step 2 - Gere um relatório detalhado.

vipin@laptop:~/chef-repo $ foodcritic -C ./cookbooks/mysql 
cookbooks/<cookbook Name>/attributes/server.rb 
FC002: Avoid string interpolation where not required 
[...] 
85| default['<Cookbook Name>']['conf_dir'] = "#{mysql['basedir']}" 
[...] 
cookbooks/<Cookbook Name>/recipes/client.rb 
FC007: Ensure recipe dependencies are reflected in cookbook 
metadata 
40| end 
41|when "mac_os_x" 
42| include_recipe 'homebrew' 
43|end 
44|

Método de trabalho

Foodcritic define um conjunto de regras e verifica os agentes de receita, cada um deles. Ele vem com várias regras relativas a várias áreas: estilos, conexão, atributos, string, probabilidade, pesquisa, serviços, arquivos, metadados e assim por diante.

Test Driven Development (TDD)é uma maneira de escrever um teste de unidade antes de escrever qualquer código de receita real. O teste deve ser real e deve validar o que a receita faz. Na verdade, ele deve falhar, pois não houve uma receita desenvolvida. Assim que a receita for desenvolvida, o teste deve ser aprovado.

ChefSpec é construído na popular estrutura RSpec e oferece uma sintaxe personalizada para testar a receita do Chef.

Criando ChefSpec

Step 1 - Crie um arquivo de gem contendo a gem chefSpec.

vipin@laptop:~/chef-repo $ subl Gemfile 
source 'https://rubygems.org' 
gem 'chefspec'

Step 2 - Instale a gema.

vipin@laptop:~/chef-repo $ bundler install 
Fetching gem metadata from https://rubygems.org/ 
...TRUNCATED OUTPUT... 
Installing chefspec (1.3.1) 
Using bundler (1.3.5) 
Your bundle is complete!

Step 3 - Crie um diretório de especificações.

vipin@laptop:~/chef-repo $ mkdir cookbooks/<Cookbook Name>/spec

Step 4 - Crie uma especificação

vipin@laptop:~/chef-repo $ subl  
cookbooks/my_cookbook/spec/default_spec.rb  
require 'chefspec'  
describe 'my_cookbook::default' do  
   let(:chef_run) {  
      ChefSpec::ChefRunner.new(  
         platform:'ubuntu', version:'12.04'  
      ).converge(described_recipe)  
   }  

   it 'creates a greetings file, containing the platform  
   name' do  
      expect(chef_run).to  
      create_file_with_content('/tmp/greeting.txt','Hello! ubuntu!')  
   end  
end

Step 5 - Valide ChefSpec.

vipin@laptop:~/chef-repo $ rspec cookbooks/<Cookbook Name>/spec/default_spec.rb 
F 
Failures: 
1) <CookBook Name> ::default creates a greetings file, containing the platform name 
Failure/Error: expect(chef_run.converge(described_recipe)).to 
create_file_with_content('/tmp/greeting.txt','Hello! ubuntu!') 
File content: 
does not match expected: 
Hello! ubuntu! 
# ./cookbooks/my_cookbook/spec/default_spec.rb:11:in `block 
(2 levels) in <top (required)>' 
Finished in 0.11152 seconds 
1 example, 1 failure  

Failed examples: 
rspec ./cookbooks/my_cookbook/spec/default_spec.rb:10 # my_ 
cookbook::default creates a greetings file, containing the 
platform name

Step 6 - Editar receita padrão de Cookbooks.

vipin@laptop:~/chef-repo $ subl cookbooks/<Cookbook Name>/recipes/default.rb 
template '/tmp/greeting.txt' do 
   variables greeting: 'Hello!' 
end

Step 7 - Crie um arquivo de modelo.

vipin@laptop:~/chef-repo $ subl cookbooks/< Cookbook Name>/recipes/default.rb 
<%= @greeting %> <%= node['platform'] %>!

Step 8 - Execute o rspec novamente.

vipin@laptop:~/chef-repo $ rspec cookbooks/<Cookbook Name>/spec/default_spec.rb 
. 
Finished in 0.10142 seconds 
1 example, 0 failures

Como funciona

Para fazer isso funcionar, precisamos primeiro configurar a infraestrutura básica para usar o RSpec com o Chef. Então precisamos ChefSpec Ruby gem e o livro de receitas precisa de um diretório chamado spec onde todos os testes serão salvos.

A cozinha de teste é a estrutura de teste de integração do Chef. Ele permite escrever testes, que são executados depois que a VM é instanciada e convergida usando o livro de receitas. Os testes são executados na VM e podem verificar se tudo funciona conforme o esperado.

Este é o contrato de nó para ChefSpec, que simula apenas uma execução de Chef. O Test Kitchen inicializa um nó real e executa o Chef nele.

Configurando

Para fazer isso, precisamos ter o Vagrant instalado na máquina, o que ajuda no gerenciamento de uma máquina virtual. Então, precisamos ter a estante de livros instalada e conectada ao Vagrant para gerenciar as dependências do livro de receitas.

Step 1 - Edite a receita padrão no livro de receitas.

vipin@laptop:~/chef-repo $ subl cookbooks/<Cookbook Name>/recipes/default.rb 
file "/tmp/greeting.txt" do 
   content node['my_cookbook']['greeting'] 
end

Step 2 - Editar atributos do livro de receitas.

vipin@laptop:~/chef-repo $ subl cookbooks/<Cookbook Name>/attributes/default.rb 
default['my_cookbook']['greeting'] = "Ohai, Chefs!"

Step 3 - Edite o arquivo gem para instalar as gemas Ruby necessárias.

vipin@laptop:~/chef-repo $ subl Gemfile 
gem 'test-kitchen', '~> 2.0.0.alpha.7' 
gem 'kitchen-vagrant'

Step 4 - Instale a gema Ruby necessária.

vipin@laptop:~/chef-repo $ bundle install 
...TRUNCATED OUTPUT... 
Installing test-kitchen (1.0.0.alpha.7) 
Installing kitchen-vagrant (0.10.0) ...TRUNCATED OUTPUT...

Step 5 - Crie o arquivo .kitchen.yml no livro de receitas.

vipin@laptop:~/chef-repo/cookbooks/my_cookbook $ subl .kitchen.yml 
--- 
driver_plugin: vagrant 
driver_config: 
   require_chef_omnibus: true  
platforms: 
   - name: ubuntu-12.04 
  driver_config: 
      box: opscode-ubuntu-12.04 
      box_url: 
         https://opscode-vm.s3.amazonaws.com/vagrant/
            opscode_ubuntu12.04_provisionerless.box  
suites: 
   - name: default 
   run_list: 
      - recipe[minitest-handler] 
      - recipe[my_cookbook_test] 
attributes: { my_cookbook: { greeting: 'Ohai, Minitest!'} }

Step 6 - Crie um diretório de teste dentro do livro de receitas.

vipin@laptop:~/chef-repo/cookbooks/<Cookbook Name>$ mkdir test

Step 7 - Crie um livro de receitas de teste para o teste de integração.

vipin@laptop:~/chef-repo/cookbooks/<Cookbook Name>/test $ knife 
cookbook create my_cookbook_test 
** Creating cookbook my_cookbook_test 
** Creating README for cookbook: my_cookbook_test 
** Creating CHANGELOG for cookbook: my_cookbook_test 
** Creating metadata for cookbook: my_cookbook_test

Step 8 - Editar receita padrão de livros de receitas de teste.

vipin@laptop:~/chef-repo/cookbooks/my_cookbook $ subl 
test/cookbooks/my_cookbook_test/recipes/default.rb 
include_recipe 'my_cookbook::default'

Step 9 - Crie especificações do Minitest dentro do livro de receitas.

vipin@laptop:~/chef-repo/cookbooks/my_cookbook $ mkdir -p 
   test/cookbooks/my_cookbook_test/files/default/tests/minitest  

vipin@laptop:~/chef-repo/cookbooks/my_cookbook $ subl 
   test/cookbooks/my_cookbook_test/files/default/tests/minitest/default_test.rb  

require 'minitest/spec'  
describe_recipe 'my_cookbook::default' do 
   describe "greeting file" do 
      it "creates the greeting file" do 
         file("/tmp/greeting.txt").must_exist 
      end 
       
      it "contains what's stored in the 'greeting' node 
         attribute" do 
         file('/tmp/greeting.txt').must_include 'Ohai, Minitest!' 
      end 
end

Step 10 - Edite o Berksfile do seu livro de receitas principal.

vipin@laptop:~/chef-repo/cookbooks/my_cookbook $ subl Berksfile 
site :opscode 
metadata 
cookbook "apt" 
cookbook "minitest-handler" 
cookbook "my_cookbook_test", path: 
"./test/cookbooks/my_cookbook_test"

Testando a configuração

vipin@laptop:~/chef-repo/cookbooks/my_cookbook $ kitchen test 
-----> Starting Kitchen (v1.0.0.alpha.7) 
...TRUNCATED OUTPUT... 
-----> Converging <default-ubuntu-1204> 
-----> Installing Chef Omnibus (true) 
...TRUNCATED OUTPUT... 
Starting Chef Client, version 11.4.4 
[2013-06-29T18:33:57+00:00] INFO: *** Chef 11.4.4 *** 
[2013-06-29T18:33:58+00:00] INFO: Setting the run_list to 
["recipe[minitest-handler]", "recipe[my_cookbook_test]"] 
from JSON 
...TRUNCATED OUTPUT... 
# Running tests: 
recipe::my_cookbook::default::greeting 
file#test_0001_creates the greeting file = 0.00 s = . 
recipe::my_cookbook::default::greeting 
file#test_0002_contains what's stored in the 'greeting' 
node attribute = 0.00 s = . 
Finished tests in 0.011190s, 178.7277 tests/s, 178.7277 
assertions/s. 
2 tests, 2 assertions, 0 failures, 0 errors, 0 skips 
...TRUNCATED OUTPUT...  
-----> Kitchen is finished. (2m5.69s)

Knife preflight mostra detalhes sobre todos os nós que usam um determinado livro de receitas antes de enviá-lo ao servidor Chef.

Começando

Para começar, precisamos ter a gema de comprovação de faca instalada.

Step 1 - Defina o caminho no arquivo gem.

vipin@laptop:~/chef-repo $ subl Gemfile 
source 'https://rubygems.org' 
gem 'knife-preflight'

Step 2 - Execute o bundler para instalar a gema de simulação de faca.

vipin@laptop:~/chef-repo $ bundle install 
Fetching gem metadata from https://rubygems.org/ 
...TRUNCATED OUTPUT... 
Installing knife-preflight (0.1.6)

Método de trabalho

Execute o pré-lançamento de faca no livro de receitas fornecido.

Podemos executar o comando preflight para descobrir quais nós e funções têm o livro de receitas fornecido em suas listas de execução expandidas.

vipin@laptop:~/chef-repo $ knife preflight ntp 
Searching for nodes containing ntp OR ntp::default in their 
expanded run_list... 
2 Nodes found 
www-staging.example.com 
cms-staging.example.com 
Searching for roles containing ntp OR ntp::default in their 
expanded run_list... 
3 Roles found 
your_cms_role 
your_www_role 
your_app_role 
Found 6 nodes and 3 roles using the specified search 
criteria

Existem várias maneiras de um livro de receitas ser executado no nó.

  • Você pode atribuir o livro de receitas diretamente a um nó, adicionando-o à lista de execução do nó.

  • Você pode adicionar um livro de receitas à função e adicionar a função à lista de execução do nó.

  • Você pode adicionar a função à lista de execução de outra função e adicionar essa outra função à lista de execução do nó.

  • Um livro de receitas pode ser uma dependência de outro livro de receitas usado.

Não importa como um livro de receitas termina na lista de execução de um nó, o comando faca preflight irá pegá-lo, pois o Chef armazena todas as listas expandidas de funções e receitas nos atributos do nó. O comando de comprovação de faca emite uma busca por exatamente esses atributos de nó.

Para testar a execução do Chef-Client, precisamos ter o Chef-Client configurado para usar o Chef hospedado ou o próprio servidor hospedado.

Executando Chef-Client no modo de depuração

vipin@server:~$ sudo chef-client -l debug 
…TRUNCATED OUTPUT… 
Hashed Path:A+WOcvvGu160cBO7IFKLYPhh9fI= 
X-Ops-Content-Hash:2jmj7l5rSw0yVb/vlWAYkK/YBwk= 
X-Ops-Timestamp:2012-12-27T11:14:07Z 
X-Ops-UserId:vagrant' 
Header hash: {"X-Ops-Sign"=>"algorithm=sha1;version=1.0;", 
"X-Ops-Userid"=>"vagrant", "X-Ops-Timestamp"=>"2012-12- 
27T11:14:07Z", "X-Ops-Content- 
Hash"=>"2jmj7l5rSw0yVb/vlWAYkK/YBwk=", "X-Ops- 
Authorization- 
1"=>"HQmTt9U/ 
LJJVAJXWtyOu3GW8FbybxAIKp4rhiw9O9O3wtGYVHyVGuoilWDao", 
"X-Ops-Authorization- 
2"=>"2/uUBPWX+YAN0g1/ 
fD2854QAU2aUcnSaVM0cPNNrldoOocmA0U5HXkBJTKok", 
"X-Ops-Authorization- 
3"=>"6EXPrEJg5T+ 
ddWd5qHAN6zMqYc3untb41t+eBpigGHPhtn1LLInMkPeIYwBm", 
"X-Ops-Authorization- 
4"=>"B0Fwbwz2HVP3wEsYdBGu7yOatq7fZBXHfIpeOi0kn/ 
Vn0P7HrucnOpONmMgU", "X-Ops-Authorization- 
5"=>"RBmmbetFSKCYsdg2v2mW/ 
ifLIVemhsHyOQjffPYPpNIB3U2n7vji37NxRnBY", 
"X-Ops-Authorization- 
6"=>"Pb3VM7FmY60xKvWfZyahM8y8WVV9xPWsD1vngihjFw=="} 
[2012-12-27T11:14:07+00:00] DEBUG: Sending HTTP Request via 
GET to api.opscode.com:443/organizations/agilewebops/ 
nodes/vagrant
[2012-12-27T11:14:09+00:00] DEBUG: ---- HTTP Status and 
Header Data: ---- 
[2012-12-27T11:14:09+00:00] DEBUG: HTTP 1.1 200 OK 
[2012-12-27T11:14:09+00:00] DEBUG: server: nginx/1.0.5 
[2012-12-27T11:14:09+00:00] DEBUG: date: Thu, 27 Dec 2012

Inspecionando o Resultado da Última Execução do Chef-Cliente

Para verificar a última execução do Chef-Client, especialmente os problemas de falha quando estamos desenvolvendo um novo livro de receitas, precisamos saber exatamente o que deu errado. Mesmo que Chef imprima tudo em stdout, pode-se querer ver o log de depuração novamente.

Se quisermos testar, precisamos ter um livro de receitas quebrado que está falhando na compilação.

user@server:~$ sudo chef-client 
================================================================== 
============== 
Recipe Compile Error in /srv/chef/file_store/cookbooks/my_ 
cookbook/recipes/default.rb 
================================================================== 
============== 
NoMethodError 
------------- 
undefined method `each' for nil:NilClass 
Cookbook Trace: 
--------------- 
/srv/chef/file_store/cookbooks/my_cookbook/recipes/default. 
rb:9:in `from_file' 
Relevant File Content: 
---------------------- 
/srv/chef/file_store/cookbooks/my_cookbook/recipes/default.rb: 
2: # Cookbook Name:: my_cookbook 
3: # Recipe:: default 
4: # 
5: # Copyright 2013, YOUR_COMPANY_NAME 
6: # 
7: # All rights reserved - Do Not Redistribute 
8: # 
9≫ nil.each {}  
10:

Para mais detalhes, podemos examinar o stacktrace.

user@server:~$ less /srv/chef/file_store/chef-stacktrace.out 
Generated at 2013-07-21 18:34:05 +0000 
NoMethodError: undefined method `each' for nil:NilClass 
/srv/chef/file_store/cookbooks/my_cookbook/recipes/default.rb:9:in 
`from_file' 
/opt/chef/embedded/lib/ruby/gems/1.9.1/gems/chef-11.4.4/lib/chef/ 
mixin/from_file.rb:30:in `instance_eval' 
/opt/chef/embedded/lib/ruby/gems/1.9.1/gems/chef-11.4.4/lib/chef/ 
mixin/from_file.rb:30:in `from_file' 
/opt/chef/embedded/lib/ruby/gems/1.9.1/gems/chef-11.4.4/lib/chef/ 
cookbook_version.rb:346:in `load_recipe'

Os atributos são os principais componentes para configurar dinamicamente os livros de receitas. Os atributos permitem que os autores tornem o livro de receitas configurável. Ao substituir os valores padrão definidos nos livros de receitas, o usuário pode injetar seus próprios valores.

Step 1 - Crie um arquivo padrão para os atributos do livro de receitas e adicione um atributo padrão a ele.

vipin@laptop:~/chef-repo $ subl cookbooks/my_cookbook/attributes/default.rb 
default['my_cookbook']['message'] = 'hello world!'

Step 2 - Defina o atributo dentro da receita.

vipin@laptop:~/chef-repo $ subl cookbooks/<Cookbook Name>/recipes/default.rb 
message = node['my_cookbook']['message'] 
Chef::Log.info("** Saying what I was told to say: #{message}")

Step 3 - Carregando o livro de receitas modificado.

vipin@laptop:~/chef-repo $ knife cookbook upload my_cookbook 
Uploading my_cookbook [0.1.0]

Step 4 - Executando Chef-Client do nó definido.

user@server:~$ sudo chef-client 
...TRUNCATED OUTPUT... 
[2013-01-13T20:48:21+00:00] INFO: ** Saying what I was told to 
say: hello world! 
...TRUNCATED OUTPUT...

Método de trabalho

Chef carrega todos os atributos do arquivo de atributos antes de executá-los. Os atributos são armazenados com o objeto de nó. Pode-se acessar todos os atributos armazenados com o objeto de nó nas receitas e recuperar seus valores atuais.

Chef tem uma estrutura restrita começando do padrão sendo o mais baixo, então vem normal (que é um alias com o conjunto) e então sobrescreve. O nível de atributo definido na receita tem precedência sobre o mesmo nível definido em um arquivo de atributo.

Substituindo Atributo no Nível do Nó e do Ambiente

Atributos definidos em funções ou ambiente têm a precedência mais alta.

Step 1 - Crie uma função.

vipin@laptop:~/chef-repo $ subl roles/german_hosts.rb 
name "german_hosts" 
description "This Role contains hosts, which should print out 
their messages in German" 
run_list "recipe[my_cookbook]" 
default_attributes "my_cookbook" => { "message" => "Hallo Welt!" }

Step 2 - Carregue a função para o servidor Chef.

vipin@laptop:~/chef-repo $ knife role from file german_hosts.rb 
Updated Role german_hosts!

Step 3 - Atribuir a função a um nó.

vipin@laptop:~/chef-repo $ knife node edit server 
"run_list": [ 
   "role[german_hosts]" 
] 
Saving updated run_list on node server

Step 4 - Execute o Chef-Client.

user@server:~$ sudo chef-client 
...TRUNCATED OUTPUT... 
[2013-01-13T20:49:49+00:00] INFO: ** Saying what I was told to 
say: Hallo Welt! 
...TRUNCATED OUTPUT...

Na infraestrutura, configuration managementé tudo sobre como configurar os hosts. Em geral, todas as configurações são feitas usando os arquivos de configuração. O Chef usa modelos para poder preencher o arquivo de configuração com valores dinâmicos.

O Chef fornece modelos como recurso que podem ser usados ​​na receita. Os valores dinâmicos dos arquivos de configuração podem ser recuperados de pacotes de dados, atributos ou até mesmo calculá-los passando-os para o modelo.

Como usá-lo?

Step 1 - Adicione o modelo à receita.

vipin@laptop:~/chef-repo $ subl cookbooks/<Cookbook Name>/recipes/default.rb  
template '/tmp/message' do 
   source 'Test.erb' 
   variables( 
      hi: 'Tesing', 
      world: 'Welt', 
      from: node['fqdn'] 
   ) 
end

Step 2 - Adicionar ERB Arquivo de modelo.

vipin@laptop:~/chef-repo $ subl cookbooks/<Cookbook Name>/templates/default/test.erb 
<%- 4.times do %> 
<%= @hi %>, <%= @world %> from <%= @from %>! 
<%- end %>

Step 3 - Carregue o livro de receitas modificado para o servidor Chef.

vipin@laptop:~/chef-repo $ knife cookbook upload <Cookbook Name> 
Uploading my_cookbook [0.1.0] 
Run Chef Client on your node: 
user@server:~$ sudo chef-client 
...TRUNCATED OUTPUT... 
[2017-01-14T20:41:21+00:00] INFO: Processing template[/tmp/ 
message] action create (my_cookbook::default line 9) 
[2017-01-14T20:41:22+00:00] INFO: template[/tmp/message] updated 
content

Step 4 - Valide o conteúdo do arquivo carregado.

user@server:~$ sudo cat /tmp/message 
Hallo, Welt from vagrant.vm! 
Hallo, Welt from vagrant.vm! 
Hallo, Welt from vagrant.vm! 
Hallo, Welt from vagrant.vm!

Fluxo de Trabalho

Chef usa Erubis como linguagem de modelo. Ele permite embutir código Ruby puro dentro de símbolos especiais nos modelos.

  • <% =%> é usado se você deseja imprimir o valor de uma variável ou expressão Ruby no arquivo gerado.

  • <% -%> é usado se você deseja embutir a lógica Ruby em seu arquivo de modelo. Nós o usamos para repetir nossa expressão quatro vezes.

No Chef, se for necessário criar receitas simples, pode-se usar os recursos disponíveis no Chef, como templates, remote_file e serviços. No entanto, conforme as receitas se tornam elaboradas, são necessárias técnicas avançadas, como declarações condicionais, para executar partes da receita sob condição. Este é o poder de misturar Ruby simples com Chef Domain Specific Language (DSL).

Como usá-lo?

Inicie o Chef Shell em qualquer nó no modo cliente para poder acessar o servidor Chef.

user@server:~$ sudo chef-shell --client 
loading configuration: /etc/chef/client.rb 
Session type: client 
...TRUNCATED OUTPUT... 
run `help' for help, `exit' or ^D to quit. 
Ohai2u user@server! 
Chef>

Condições básicas com Chef DSL

Classifique os nós por nome usando Ruby simples.

chef > nodes.sort! {|a,b| a.name <=> b.name } 
=> [node[alice],node[server]]

Percorra os nós, imprimindo seu sistema operacional.

chef > nodes.each do |n| 
   chef > puts n['os'] 
   chef ?> 
end  
linux 
windows 
=> [node[server], node[alice]]

Instale várias gemas Ruby usando um array, um loop e uma expansão de string para construir os nomes das gemas.

chef > %w{ec2 essentials}.each do |gem| 
   chef > gem_package "knife-#{gem}" 
   chef ?> end   => ["ec2", "essentials"]

Método de trabalho

As receitas do Chef são arquivos Ruby, que são avaliados no contexto da execução do Chef. Eles podem conter código Ruby simples, como instrução if e loops, bem como elementos DSL do Chef, como recursos.

Dentro da receita, pode-se simplesmente declarar variáveis ​​Ruby e atribuir valores a elas.

As receitas são os principais blocos de construção do livro de receitas, que é basicamente código Ruby. É possível usar todos os recursos da linguagem Ruby dentro da receita do Chef. Na maioria das vezes, a funcionalidade de compilação de Ruby é suficiente, mas às vezes pode ser necessário usar gemas Ruby adicionais. Por exemplo, se for necessário acessar o banco de dados MySQL da própria receita.

A receita do Chef tem a capacidade de obter as joias Ruby necessárias para usá-las dentro da mesma receita.

Usando iptable Gem na receita dada

Step 1 - Edite a receita padrão do livro de receitas e instale a gema a ser usada dentro da receita.

vipin@laptop:~/chef-repo $ subl 
cookbooks/my_cookbook/recipes/default.rb 
chef_gem 'ipaddress' 
require 'ipaddress' 
ip = IPAddress("192.168.0.1/24") 
Chef::Log.info("Netmask of #{ip}: #{ip.netmask}")

Step 2 - Carregue o livro de receitas modificado para o servidor Chef.

vipin@laptop:~/chef-repo $ knife cookbook upload my_cookbook 
Uploading my_cookbook [0.1.0]

Step 3 - Executar o cliente Chef para ver a saída.

user@server $ sudo chef-client 
...TRUNCATED OUTPUT... 
[2013-01-18T14:02:02+00:00] INFO: Netmask of 192.168.0.1: 
255.255.255.0 
...TRUNCATED OUTPUT...

Método de trabalho

As etapas de execução do Chef consistem na fase de compilação, em que ele compila todos os recursos e uma fase de execução em que Chef executa os provedores de recursos para convergir o nó para o estado desejado. Se alguém precisa de alguma gema Ruby específica dentro do livro de receitas, é necessário instalar a gema durante a fase de complicação.

O recurso chef_gem fará exatamente o mesmo e, no Chef, Omnibus é a única maneira de trabalhar. Sua principal função é colocar as gemas à disposição do próprio Chef.

As bibliotecas no Chef fornecem um local para encapsular a lógica compilada para que as receitas do livro de receitas permaneçam organizadas e limpas.

Criação da biblioteca

Step 1 - Crie um método auxiliar na biblioteca do livro de receitas.

vipin@laptop:~/chef-repo $ subl cookbooks/my_cookbook/libraries/ipaddress.rb 
class Chef::Recipe 
def netmask(ipaddress) 
IPAddress(ipaddress).netmask 
end 
end

Step 2 - Use o método auxiliar.

vipin@laptop:~/chef-repo $ subl cookbooks/my_cookbook/recipes/default.rb 
ip = '10.10.0.0/24' 
mask = netmask(ip) # here we use the library method 
Chef::Log.info("Netmask of #{ip}: #{mask}")

Step 3 - Carregue o livro de receitas modificado para o Chef Server.

vipin@laptop:~/chef-repo $ knife cookbook upload my_cookbook 
Uploading my_cookbook [0.1.0]

Testando a Biblioteca

user@server $ sudo chef-client 
...TRUNCATED OUTPUT... 
[2013-01-18T14:38:26+00:00] INFO: Netmask of 10.10.0.0/24: 
255.255.255.0 
...TRUNCATED OUTPUT...

Método de trabalho

O código da biblioteca Chef pode abrir a classe chef :: Recipe e adicionar novos métodos conforme feito na Etapa 1. Esta etapa não é a mais limpa, mas a maneira mais simples de fazê-lo.

class Chef::Recipe 
def netmask(ipaddress) 
... 
end 
end

Melhores Práticas

Assim que abrirmos a classe chef :: recipe, haverá mudanças que ela ficará poluída. Como prática recomendada, é sempre a melhor maneira de introduzir uma nova subclasse dentro da biblioteca e definir um método como método de classe. Isso evita puxar o namespace chef :: recipe.

vipin@laptop:~/chef-repo $ subl cookbooks/my_cookbook/libraries/ipaddress.rb 
class Chef::Recipe::IPAddress 
def self.netmask(ipaddress) 
IPAddress(ipaddress).netmask 
end 
end

Podemos usar o método dentro da receita como

IPAddress.netmask(ip)

A definição pode ser definida como um método lógico de agrupar recursos, que são usados ​​repetidamente. Neste fluxo, agrupamos os recursos e atribuímos a eles um nome para recuperar a legibilidade dos livros de receitas definidos.

Para fazer isso, devemos ter uma receita. Nesse caso, estamos usando test_cookbook e uma lista de execução de nós, que inclui o livro de receitas.

Criação de uma definição

Step 1 - Crie um novo arquivo de definição na pasta de definição de livros de receitas.

vipin@laptop:~/chef-repo $ subl cookbooks/test_cookbook/definitions/ 
capistrano_deploy_dirs.rb 
define :capistrano_deploy_dirs, :deploy_to => '' do 
   directory "#{params[:deploy_to]}/releases" 
   directory "#{params[:deploy_to]}/shared" 
   directory "#{params[:deploy_to]}/shared/system" 
end

Step 2 - Use uma definição dentro da receita padrão do livro de receitas.

vipin@laptop:~/chef-repo $ subl cookbooks/test_cookbook/recipes/default.rb 
capistrano_deploy_dirs do 
   deploy_to "/srv" 
end

Step 3 - Faça upload do livro de receitas para o servidor do chef.

vipin@laptop:~/chef-repo $ knife cookbook upload test_cookbook 
Uploading test_cookbook [0.1.0]

Step 4 - Execute o cliente Chef no nó desejado.

vipin@laptop:~/chef-repuser@server $ sudo chef-client 
...TRUNCATED OUTPUT... 
[2013-01-18T16:31:11+00:00] INFO: Processing directory[/srv/ 
releases] action create (my_cookbook::default line 2) 
[2013-01-18T16:31:11+00:00] INFO: directory[/srv/releases] created 
directory /srv/releases 
[2013-01-18T16:31:11+00:00] INFO: Processing directory[/srv/ 
shared] action create (my_cookbook::default line 3) 
[2013-01-18T16:31:11+00:00] INFO: directory[/srv/shared] created 
directory /srv/shared 
[2013-01-18T16:31:11+00:00] INFO: Processing directory[/srv/ 
shared/system] action create (my_cookbook::default line 4) 
[2013-01-18T16:31:11+00:00] INFO: directory[/srv/shared/system]

A definição em livros de receitas é como micros, que agrupam os recursos e lhes dão um nome. Uma definição tem um nome pelo qual se pode dizer qual pode ser chamado dentro da receita e tem uma lista de perímetros.

Na definição, temos parâmetros que em nosso código se parecem com o seguinte.

….. 
directory "#{params[:deploy_to]}/releases" 
directory "#{params[:deploy_to]}/shared" 
directory "#{params[:deploy_to]}/shared/system” 
……

Ele pode ser usado dentro da receita padrão da seguinte maneira.

capistrano_deploy_dirs do 
   deploy_to "/srv"` 
end

A variável de ambiente é uma forma importante de fazer a receita do Chef ser executada em qualquer nó específico com sucesso. Existem várias maneiras de fazer isso, seja configurando-as manualmente ou usando um script Shell. Configurá-los via receita é o que precisamos fazer aqui.

Para fazer isso, precisamos ter um livro de receitas aqui, usaríamos test_cookbook e uma lista de execução que contém test_cookbook.

Definindo a variável de ambiente usando a receita do Chef

Step 1 - Atualize a receita padrão do livro de receitas com uma variável de ambiente.

vipin@laptop:~/chef-repo $ subl cookbooks/test_cookbook/recipes/default.rb  
ENV['MESSAGE'] = 'Testing environment variable update with chef !'  
execute 'print value of environment variable $MESSAGE' do command 'echo $MESSAGE > /tmp/message' 
end

Step 2 - Carregue o livro de receitas atualizado para o servidor.

vipin@laptop:~/chef-repo $ knife cookbook upload test_cookbook 
Uploading my_cookbook [0.1.0]

Step 3 - Executar o cliente Chef para criar um arquivo temporário.

user@server:~$ sudo chef-client 
...TRUNCATED OUTPUT... 
[2013-01-25T15:01:57+00:00] INFO: Processing execute[print 
value of environment variable $MESSAGE] action run (my_cookbook::default line 11) [2013-01-25T15:01:57+00:00] INFO: execute[print value of environment variable $MESSAGE] ran successfully 
...TRUNCATED OUTPUT...

Validando Variável

user@server:~$ cat /tmp/message 
Hello from Chef

Método de trabalho

Ruby expõe a variável de ambiente atual via ENV –a hash para ler e modificar a variável de ambiente.

Executar recurso

Podemos usar o recurso execute para fazer o mesmo dentro da receita padrão do livro de receitas do Chef.

mma@laptop:~/chef-repo $ subl cookbooks/test_cookbook/recipes/default.rb  
execute 'print value of environment variable $MESSAGE' do command 'echo $MESSAGE > /tmp/message' 
   environment 'MESSAGE' => 'Hello from the execute resource' 
end

Note- Definir uma variável de ambiente usando ENV tornará essa variável disponível durante toda a execução do Chef. Em contraste, passá-lo para o recurso execute apenas o tornará disponível para aquele comando executado pelo recurso.

Os sacos de dados do Chef podem ser definidos como uma coleção arbitrária de dados que pode ser usada com livros de receitas. Usar sacos de dados é muito útil quando não se deseja codificar atributos em receitas nem armazenar atributos em livros de receitas.

Método de trabalho

Na configuração a seguir, estamos tentando nos comunicar com o URL do endpoint http. Para isso, precisamos criar um saco de dados, que conterá os detalhes da URL do endpoint e os usará em nossa receita.

Step 1 - Crie um diretório para nossa bolsa de dados.

mma@laptop:~/chef-repo $ mkdir data_bags/hooks

Step 2- Crie um item de saco de dados para o compartimento de solicitação. É preciso ter certeza de que está usando um URL requestBin definido.

vipi@laptop:~/chef-repo $ subl data_bags/hooks/request_bin.json { 
   "id": "request_bin", 
   "url": "http://requestb.in/1abd0kf1" 
}

Step 3 - Crie uma bolsa de dados no servidor Chef

vipin@laptop:~/chef-repo $ knife data bag create hooks 
Created data_bag[hooks]

Step 4 - Carregue a bolsa de dados para o servidor Chef.

vipin@laptop:~/chef-repo $ knife data bag from file hooks requestbin.json 
Updated data_bag_item[hooks::RequestBin]

Step 5 - Atualize a receita padrão do livro de receitas para receber o livro de receitas necessário de um saco de dados.

vipin@laptop:~/chef-repo $ subl cookbooks/my_cookbook/recipes/default.rb 
hook = data_bag_item('hooks', 'request_bin') 
http_request 'callback' do 
   url hook['url'] 
end

Step 6 - Carregue o livro de receitas modificado para o servidor Chef.

vipin@laptop:~/chef-repo $ knife cookbook upload my_cookbook 
Uploading my_cookbook [0.1.0]

Step 7 - Execute o cliente Chef no nó para verificar se o bin de solicitação http é executado.

user@server:~$ sudo chef-client 
...TRUNCATED OUTPUT... 
[2013-02-22T20:37:35+00:00] INFO: http_request[callback] 
GET to http://requestb.in/1abd0kf1 successful 
...TRUNCATED OUTPUT...

Como funciona

Saco de dados é uma coleção nomeada de entradas de dados de estrutura. É necessário definir a entrada de dados e chamar o item do saco de dados no arquivo JSON. Também é possível pesquisar por itens de saco de dados dentro das receitas para usar os dados armazenados nos sacos de dados.

Criamos uma bolsa de dados chamada ganchos. Um data bag é um diretório dentro do repositório Chef. Usamos faca para criá-lo no servidor.

Em certas condições, não é possível colocar o servidor sob o controle total do Chef. Nesses casos, pode ser necessário acessar os valores nos pacotes de dados do Chef a partir de scripts. Para fazer isso, é necessário armazenar os valores do saco de dados em um arquivo JSON e permitir que o script adicionado acesse esses valores.

Para isso, é preciso ter um livro de receitas. Em nosso caso, usaríamos test_cookbook como anteriormente e devemos ter a lista de execução do nó incluindo a definição de test_cookbook nela.

Método de trabalho

Step 1 - Crie uma bolsa de dados.

vipin@laptop:~/chef-repo $ mkdir data_bags/servers 
vipin@laptop:~/chef-repo $ knife data bag create servers 
Created data_bag[servers]

Step 2 - Crie um item de saco de dados.

vipin@laptop:~/chef-repo $ subl data_bags/servers/Storage.json { 
   "id": "storage", 
   "host": "10.0.0.12" 
}

Step 3 - Atualize o item do saco de dados.

vipin@laptop:~/chef-repo $ subl data_bags/servers/Storage.json { 
   "id": "storage", 
   "host": "10.0.0.12" 
}

Usando no livro de receitas

Step 1 - É necessário criar um arquivo JSON contendo valores de bolsa de dados usando o livro de receitas acima para que scripts externos possam acessar esses valores.

vipin@laptop:~/chef-repo $ subl cookbooks/test_cookbook/recipes/default.rb 
file "/etc/backup_config.json" do 
   owner "root"
   group "root" 
   mode 0644 
   content data_bag_item('servers', 'backup')['host'].to_json 
end

Step 2 - Carregar test_cookbook para o servidor Chef.

vipin@laptop:~/chef-repo $ knife cookbook upload test_cookbook 
Uploading my_cookbook [0.1.0]

Step 3 - Execute o cliente Chef no nó.

user@server:~$ sudo chef-client 
...TRUNCATED OUTPUT... 
[2013-03-14T20:30:33+00:00] INFO: Processing 
file[/etc/backup_config.json] action create 
(my_cookbook::default line 9) 
[2013-03-14T20:30:34+00:00] INFO: entered create 
[2013-03-14T20:30:34+00:00] INFO: 
file[/etc/backup_config.json] owner changed to 0 
[2013-03-14T20:30:34+00:00] INFO: 
file[/etc/backup_config.json] group changed to 0 
[2013-03-14T20:30:34+00:00] INFO: 
file[/etc/backup_config.json] mode changed to 644 
[2013-03-14T20:30:34+00:00] INFO: 
file[/etc/backup_config.json] created file 
/etc/backup_config.json 
...TRUNCATED OUTPUT...

Step 4 - Validar o conteúdo do arquivo JSON gerado.

user@server:~$ cat /etc/backup_config.json 
"10.0.0.12"

Fluxo de Trabalho de Scripts

No comando acima, o recurso de arquivo que usamos, que cria o arquivo JSON dentro do /etcdiretório é definido no livro de receitas padrão. Ele obtém o conteúdo do arquivo diretamente do saco de dados usando o método data_bag_item. Acessamos os valores do host do item do saco de dados e os convertemos em JSON. O recurso de arquivo usa os valores convertidos em JSON como seu conteúdo e os grava no disco.

Os livros de receitas multiplataforma são aqueles livros de receitas que adotam um ambiente subjacente no qual serão executados. O Chef fornece uma série de recursos, que ajudam a escrever livros de receitas de plataforma cruzada capazes de rodar em qualquer sistema operacional, no qual será implantado. Isso ajuda um desenvolvedor a escrever um livro de receitas totalmente operacional.

Para fazer isso, precisamos ter um livro de receitas. No nosso caso, será test_cookbook e uma lista de execução que conterá a definição do livro de receitas.

Método de trabalho

Recuperar os detalhes da plataforma de nós e executar a lógica condicional em nosso livro de receitas depende da plataforma. No nosso caso, iremos testá-lo para o Ubuntu.

Step 1 - Registre uma mensagem se o nó for Ubuntu.

vipin@laptop:~/chef-repo $ subl cookbooks/test_cookbook/recipes/default.rb 
Log.info("Running on ubuntu") if node.platform['ubuntu']

Step 2 - Faça upload do livro de receitas para o servidor Chef.

vipin@laptop:~/chef-repo $ subl cookbooks/test_cookbook/recipes/default.rb 
Uploading my_cookbook [0.1.0] 
Uploaded 1 cookbook.

Step 3 - Execute o cliente Chef no nó.

user@server:~$ sudo chef-client 
...TRUNCATED OUTPUT... 
[2013-03-03T20:07:39+00:00] INFO: Running on Ubuntu 
...TRUNCATED OUTPUT...

Alternativamente, se alguém não estiver interessado em uma plataforma específica, mas precisar apenas saber qual declarativa está usando, a seguinte instrução pode ser usada.

Log.info("Running on a debian derivative") if 
platform_family?('debian')

Carregar o livro de receitas modificado e executar o cliente Chef no nó Ubuntu mostrará o seguinte resultado.

[2013-03-03T20:16:14+00:00] INFO: Running on a debian 
derivative

Fluxo de Trabalho de Scripts

No comando acima, Ohai descobrirá o status atual do sistema operacional do nó e o armazenará como um atributo de plataforma com o objeto do nó.

node['platform']

Ou você pode usar a sintaxe de estilo de método -

node.platform

Definição de valores específicos da plataforma

Para definir os valores específicos da plataforma, o chef oferece métodos de conveniência value_for_platform e value_for_platform_family. Eles podem ser usados ​​para evitar declarações complexas de caso e, em vez disso, usar um hash simples.

Livro de receitas de exemplo

execute "start-runsvdir" do 
   command value_for_platform( 
      "debian" => { "default" => "runsvdir-start" }, 
      "ubuntu" => { "default" => "start runsvdir" }, 
      "gentoo" => { "default" => "/etc/init.d/runit-start start" } 
   ) 
   action :nothing 
end

No exemplo acima, o comando é específico do sistema operacional conforme definido.

  • Para Debian, "runsvdir-start" funcionará
  • Para Ubuntu, "start runsvdir" funcionará
  • Para Gentoo, "/etc/init.d/runit-start" funcionará

O recurso Chef representa uma parte do sistema operacional em seu estado desejado. É uma declaração de política de configuração que descreve o estado desejado de um nó para o qual se deseja levar a configuração atual para usar provedores de recursos. Isso ajuda a saber o status atual da máquina de destino usando o mecanismo Ohai do Chef. Também ajuda a definir as etapas necessárias a serem executadas para que a máquina de destino atinja esse estado. Os recursos são agrupados em receitas que descrevem a configuração de trabalho.

No caso do Chef, chef :: Platform mapeia os provedores e versões de plataforma de cada nó. No início de cada execução do Chef-cliente, o servidor Chef coleta os detalhes do estado atual de qualquer máquina. Posteriormente, o servidor Chef usa esses valores para identificar o provedor correto.

Sintaxe de recursos

type 'name' do 
   attribute 'value' 
   action :type_of_action 
end

Na sintaxe acima, 'tipo' é o tipo de recurso e 'nome' é o nome que iremos usar. Nos blocos 'fazer' e 'finalizar', temos o atributo desse recurso e a ação que precisamos realizar para esse recurso específico.

Cada recurso que usamos na receita tem seu próprio conjunto de ações, que é definido dentro dos blocos 'do' e 'end'.

Exemplo

type 'name' do 
   attribute 'value' 
   action :type_of_action 
end

Todos os recursos compartilham um conjunto comum de funcionalidade, ações, propriedades, execução condicional, notificação e caminho de ação relevante.

Ações o :nothing ação pode ser usada com qualquer recurso ou recurso personalizado.
Propriedades As propriedades ignore_failure, provider, retries, retry_delay e supported podem ser usadas com qualquer recurso ou recursos personalizados.
Guardas As execuções condicionais not_if e only_if podem ser usadas para colocar guardas adicionais em torno de certos recursos, de modo que eles só sejam executados quando a condição for atendida.
Intérpretes de guarda Avalia um comando de string usando um scriptrecurso baseado em: bash, csh, perl, powershell_script, python, ou ruby.
Notificações As notificações de notificação e assinatura podem ser usadas com qualquer recurso.
Caminhos Relativos O caminho relativo # {ENV ['HOME']} pode ser usado com qualquer recurso.
Segurança de arquivos do Windows o template, file, remote_file, cookbook_file, directory, e remote_directory os recursos suportam o uso de listas de controle de herança e acesso (ACLs) nas receitas.
Executar em fase de compilação Às vezes, um recurso precisa ser executado antes de todos os outros recursos ou depois que todos os recursos foram adicionados à coleção de recursos.

Recursos disponíveis

apt_package

Use o apt_package recurso para gerenciar pacotes para as plataformas Debian e Ubuntu.

Bash

Use o bashrecurso para executar scripts usando o interpretador Bash. Este recurso também pode usar qualquer uma das ações e propriedades que estão disponíveis para oexecuterecurso. Os comandos que são executados com este recurso não são (por natureza) idempotentes, pois são tipicamente exclusivos do ambiente em que são executados. Use not_if e only_if para proteger este recurso para idempotência.

Lote

Use o batchrecurso para executar um script em lote usando o interpretador cmd.exe. obatch recurso cria e executa um arquivo temporário (semelhante a como o script recurso se comporta), em vez de executar o comando embutido.

Este recurso herda ações (: executar e: nada) e propriedades (cria, cwd, ambiente, grupo, caminho, tempo limite e usuário) do executerecurso. Os comandos que são executados com este recurso não são (por natureza) idempotentes, pois são tipicamente exclusivos do ambiente em que são executados. Usarnot_if e only_if para proteger este recurso de idempotência.

bff_package

Use o bff_package recurso para gerenciar pacotes para a plataforma AIX usando o installpUtilitário. Quando um pacote é instalado a partir de um arquivo local, ele deve ser adicionado ao nó usando oremote_file ou cookbook_file resources.

chef_gem

Use o chef_gemrecurso para instalar uma gema apenas para a instância de Ruby que é dedicada ao Chef-Client. Quando uma gem é instalada a partir de um arquivo local, ela deve ser adicionada ao nó usando oremote_file ou cookbook_file Recursos.

o chef_gem recurso funciona com todas as mesmas propriedades e opções que o gem_packagerecurso, mas não aceita a propriedade gem_binary porque sempre usa o CurrentGemEnvironment sob o qual o Chef-Client está sendo executado. Além de realizar ações semelhantes aogem_package recurso, o chef_gem recurso faz o acima.

cookbook_file

Use o cookbook_file recurso para transferir arquivos de um subdiretório de COOKBOOK_NAME / files / para um caminho especificado localizado em um host que está executando o ChefClient.

O arquivo é selecionado de acordo com a especificidade do arquivo, o que permite que diferentes arquivos de origem sejam usados ​​com base no nome do host, plataforma do host (sistema operacional, distribuição ou conforme apropriado) ou versão da plataforma. Os arquivos localizados no subdiretório COOKBOOK_NAME / files / default podem ser usados ​​em qualquer plataforma.

Cron

Use o recurso cron para gerenciar entradas cron para agendamento de trabalho baseado em tempo. As propriedades para uma programação serão padronizadas como * se não forem fornecidas. O recurso cron requer acesso a um programa crontab, normalmente cron.

Csh

Use o recurso csh para executar scripts usando o interpretador csh. Este recurso também pode usar qualquer uma das ações e propriedades disponíveis para o recurso de execução.

Os comandos que são executados com este recurso não são (por natureza) idempotentes, pois são tipicamente exclusivos do ambiente em que são executados. Use not_if e only_if para proteger este recurso para idempotência.

Implantar

Use o deployrecurso para gerenciar e controlar implantações. Este é um recurso popular, mas também complexo, tendo a maioria das propriedades, vários provedores, a complexidade adicional de retornos de chamada, além de quatro atributos que suportam modificações de layout de dentro de uma receita.

Diretório

Use o directoryrecurso para gerenciar um diretório, que é uma hierarquia de pastas que compreende todas as informações armazenadas em um computador. O diretório raiz é o nível superior, sob o qual o resto do diretório é organizado.

o directoryresource usa a propriedade name para especificar o caminho para um local em um diretório. Normalmente, é necessária permissão para acessar esse local no diretório.

dpkg_package

Use o dpkg_package recurso para gerenciar pacotes para o dpkgplataforma. Quando um pacote é instalado a partir de um arquivo local, ele deve ser adicionado ao nó usando oremote_file ou cookbook_file Recursos.

easy_install_package

Use o easy_install_package recurso para gerenciar pacotes para a plataforma Python.

Env

Use o envrecurso para gerenciar chaves de ambiente no Microsoft Windows. Depois que uma chave de ambiente é definida, o Microsoft Windows deve ser reiniciado antes que a chave de ambiente esteja disponível para o Agendador de Tarefas.

erl_call

Use o erl_callrecurso para se conectar a um nó localizado dentro de um sistema Erlang distribuído. Os comandos que são executados com este recurso não são (por natureza) idempotentes, pois são tipicamente exclusivos do ambiente em que são executados. Use not_if e only_if para proteger este recurso para idempotência.

Executar

Use o executerecurso para executar um único comando. Os comandos que são executados com este recurso não são (por natureza) idempotentes, pois são tipicamente exclusivos do ambiente em que são executados. Usarnot_if e only_if para proteger este recurso de idempotência.

Arquivo

Use o file recurso para gerenciar os arquivos diretamente em um nó.

freebsd_package

Use o freebsd_package recurso para gerenciar pacotes para a plataforma FreeBSD.

gem_package

Use o gem_packagerecurso para gerenciar pacotes de gem que são incluídos apenas nas receitas. Quando um pacote é instalado a partir de um arquivo local, ele deve ser adicionado ao nó usando oremote_file ou cookbook_file Recursos.

Git

Use o gitrecurso para gerenciar recursos de controle de origem que existem em um repositório git. O git versão 1.6.5 (ou superior) é necessário para usar todas as funcionalidades do recurso git.

Grupo

Use o group recurso para gerenciar um grupo local.

homebrew_package

Use o homebrew_package recurso para gerenciar pacotes para a plataforma Mac OS X.

http_request

Use o http_requestrecurso para enviar uma solicitação HTTP (GET, PUT, POST, DELETE, HEAD ou OPTIONS) com uma mensagem arbitrária. Este recurso geralmente é útil quando retornos de chamada personalizados são necessários.

Ifconfig

Use o ifconfig recurso para gerenciar interfaces.

ips_package

Use o ips_package recurso para gerenciar pacotes (usando o Image Packaging System (IPS)) na plataforma Solaris 11.

Ksh

Use o kshrecurso para executar scripts usando o interpretador Korn shell (ksh). Este recurso também pode usar qualquer uma das ações e propriedades disponíveis para o recurso de execução.

Os comandos que são executados com este recurso não são (por natureza) idempotentes, pois são tipicamente exclusivos do ambiente em que são executados. Use not_if e only_if para proteger este recurso para idempotência.

Ligação

Use o link recurso para criar links simbólicos ou físicos.

Registro

Use o logrecurso para criar entradas de registro. O recurso de log se comporta como qualquer outro recurso: integrado à coleção de recursos durante a fase de compilação e, em seguida, executado durante a fase de execução. (Para criar uma entrada de registro que não está incorporada na coleção de recursos, use Chef :: Log em vez do recurso de registro)

macports_package

Use o recurso macports_package para gerenciar pacotes para a plataforma Mac OS X.

Mdadm

Use o mdadmrecurso para gerenciar dispositivos RAID em um ambiente Linux usando o utilitário mdadm. O provedor mdadm criará e montará uma matriz, mas não criará o arquivo de configuração usado para persistir a matriz na reinicialização.

Se o arquivo de configuração for necessário, isso deve ser feito especificando um modelo com o layout de array correto e, em seguida, usando o provedor de montagem para criar uma entrada de tabela de sistemas de arquivos (fstab).

Monte

Use o recurso de montagem para gerenciar um sistema de arquivos montado.

Ohai

Use o ohairecurso para recarregar a configuração Ohai em um nó. Isso permite que receitas que alteram os atributos do sistema (como uma receita que adiciona um usuário) se refiram a esses atributos mais tarde durante a execução chef-cliente.

Pacote

Use o packagerecurso para gerenciar pacotes. Quando o pacote é instalado a partir de um arquivo local (como com RubyGems, dpkg ou RPM Package Manager), o arquivo deve ser adicionado ao nó usando os recursos remote_file ou cookbook_file.

pacman_package

Use o pacman_package recurso para gerenciar pacotes (usando pacman) na plataforma Arch Linux.

powershell_script

Use o powershell_scriptrecurso para executar um script usando o interpretador do Windows PowerShell, da mesma forma que o script e os recursos baseados em script - bash, csh, perl, python e ruby ​​- são usados. O powershell_script é específico para a plataforma Microsoft Windows e o interpretador do Windows PowerShell.

Pitão

Use o pythonrecurso para executar scripts usando o interpretador Python. Este recurso também pode usar qualquer uma das ações e propriedades disponíveis para o recurso de execução.

Os comandos que são executados com este recurso não são (por natureza) idempotentes, pois são tipicamente exclusivos do ambiente em que são executados. Use not_if e only_if para proteger este recurso para idempotência.

Reiniciar

Use o rebootrecurso para reinicializar um nó, uma etapa necessária com algumas instalações em certas plataformas. Este recurso tem suporte para uso nas plataformas Microsoft Windows, Mac OS X e Linux.

Chave do registro

Use o registry_key recurso para criar e excluir chaves de registro no Microsoft Windows.

remote_directory

Use o remote_directoryrecurso para transferir incrementalmente um diretório de um livro de receitas para um nó. O diretório que é copiado do livro de receitas deve estar localizado em COOKBOOK_NAME / files / default / REMOTE_DIRECTORY.

O recurso remote_directory obedecerá à especificidade do arquivo.

remote_file

Use o remote_filerecurso para transferir um arquivo de um local remoto usando a especificidade do arquivo. Este recurso é semelhante ao recurso de arquivo.

Rota

Use o recurso de rota para gerenciar a tabela de roteamento do sistema em um ambiente Linux.

rpm_package

Use o rpm_package recurso para gerenciar pacotes para a plataforma RPM Package Manager.

Rubi

Use o rubyrecurso para executar scripts usando o interpretador Ruby. Este recurso também pode usar qualquer uma das ações e propriedades disponíveis para o recurso de execução.

Os comandos que são executados com este recurso não são (por natureza) idempotentes, pois são tipicamente exclusivos do ambiente em que são executados. Use not_if e only_if para proteger este recurso para idempotência.

ruby_block

Use o ruby_blockrecurso para executar o código Ruby durante a execução do Chef-Client. O código Ruby no recurso ruby_block é avaliado com outros recursos durante a convergência, enquanto o código Ruby fora de um recurso ruby_block é avaliado antes de outros recursos, conforme a receita é compilada.

Roteiro

Use o recurso de script para executar scripts usando um interpretador especificado, como Bash, csh, Perl, Python ou Ruby. Este recurso também pode usar qualquer uma das ações e propriedades disponíveis para o recurso de execução.

Os comandos que são executados com este recurso não são (por natureza) idempotentes, pois são tipicamente exclusivos do ambiente em que são executados. Use not_if e only_if para proteger este recurso para idempotência.

Serviço

Use o service recurso para gerenciar um serviço.

smart_os_package

Use o smartos_package recurso para gerenciar pacotes para a plataforma SmartOS.

solaris_package

o solaris_package recurso é usado para gerenciar pacotes para a plataforma Solaris.

Subversão

Use o subversion recurso para gerenciar recursos de controle de origem que existem em um repositório Subversion.

Modelo

Use o templaterecurso para gerenciar o conteúdo de um arquivo usando um modelo Embedded Ruby (ERB), transferindo arquivos de um subdiretório de COOKBOOK_NAME / templates / para um caminho especificado localizado em um host que está executando o Chef-Client. Este recurso inclui ações e propriedades do recurso de arquivo. Os arquivos de modelo gerenciados pelo recurso de modelo seguem as mesmas regras de especificidade de arquivo que o remote_file e os recursos de arquivo.

Do utilizador

Use o user recurso para adicionar usuários, atualizar usuários existentes, remover usuários e para bloquear / desbloquear senhas de usuários.

windows_package

Use o windows_package recurso para gerenciar pacotes do Microsoft Installer Package (MSI) para a plataforma Microsoft Windows.

windows_service

Use o windows_service recurso para gerenciar um serviço na plataforma Microsoft Windows.

yum_package

Use o yum_packagerecurso para instalar, atualizar e remover pacotes com Yum para as plataformas Red Hat e CentOS. O recurso yum_package é capaz de resolver o fornecimento de dados para pacotes de maneira muito semelhante ao que o Yum pode fazer quando é executado na linha de comando. Isso permite uma variedade de opções para instalar pacotes, como versões mínimas, provisões virtuais e nomes de bibliotecas.

Lightweight resource provider (LWRP) fornece uma opção de estender a lista de recursos disponíveis, estendendo seus recursos e permite que o usuário Chef crie recursos personalizados.

Ao criar recursos personalizados, pode-se simplesmente escrever livros de receitas porque pode-se possuir recursos personalizados enriquecidos usando Chef DSL, que ajuda a tornar o código da receita mais expressivo.

Na comunidade Chef, muitos dos recursos personalizados são implementados usando LWRPs. Existem muitos exemplos funcionais de LWRP, comoiptables_rules e apt_repository.

Método de trabalho

Certifique-se de que existe um livro de receitas com o nome Testing_resource e uma run_list do nó que contém o livro de receitas Testing_resource.

Construindo LWRP

Step 1 - Crie um recurso personalizado no livro de receitas Testing_resource.

vipin@laptop:~/chef-repo $ subl cookbooks/Testing_resource/resources/default.rb 
actions :create, :remove 
attribute :title, kind_of: String, default: "World" 
attribute :path, kind_of: String, default: "/tmp/greeting.txt"

Step 2 - Crie um provedor de recursos no livro de receitas Tesing_resource.

vipin@laptop:~/chef-repo $ subl cookbooks/Testing_resource/provider/default.rb 
action :create do 
   log "Adding '#{new_resource.name}' greeting as #{new_resource. 
      path}" 
   file new_resource.path do 
      content "#{new_resource.name}, #{new_resource.title}!" 
      action :create 
end  
action :remove do 
   Chef::Log.info "Removing '#{new_resource.name}' greeting #{new_resource.path}" 
   file new_resource.path do 
      action :delete 
   end 
end

Step 3 - Use um novo recurso editando a receita padrão Testing_resource.

vipin@laptop:~/chef-repo $ subl cookbooks/Tesing_resource/recipes/default.rb 
greeting "Ohai" do 
   title "Chef" 
   action :create 
end

Step 4 - Carregue o livro de receitas modificado para o servidor Chef.

vipin@laptop:~/chef-repo $ knife cookbook upload greeting 
Uploading greeting [0.1.0]

Step 5 - Execute Chef-Client no nó.

vipin@server:~$ sudo chef-client 
...TRUNCATED OUTPUT... 
2013-06-28T21:32:54+00:00] INFO: Processing greeting[Ohai] action 
create (greeting::default line 9) 
[2013-06-28T21:32:54+00:00] INFO: Adding 'Ohai' greeting as /tmp/ 
greeting.txt 
[2013-06-28T21:32:54+00:00] INFO: Processing file[/tmp/greeting. 
txt] action create (/srv/chef/file_store/cookbooks/greeting/ 
providers/default.rb line 7) 
[2013-06-28T21:32:54+00:00] INFO: entered create 
[2013-06-28T21:32:54+00:00] INFO: file[/tmp/greeting.txt] created 
file /tmp/greeting.txt 
...TRUNCATED OUTPUT...

Step 6 - Valide o conteúdo do arquivo gerado.

user@server:~$ cat /tmp/greeting.txt 
Ohai, Chef!

Scripts de fluxo de trabalho

LWRPs vivem em livros de receitas. Um recurso personalizado fica dentro dos livros de receitas e estará disponível com o nome do livro de receitas. No fluxo de trabalho, primeiro definimos as definições e, em seguida, passamos os atributos aos recursos que serão usados ​​no livro de receitas. Finalmente, usamos essas ações e atributos em nossa receita.

No Chef, os blueprints são as ferramentas para descobrir e registrar exatamente o que está presente no servidor. Os blueprints registram todas as coisas necessárias, como diretores, pacotes, arquivos de configuração e assim por diante. Os blueprints têm a capacidade de dividir as informações do servidor em vários formatos. Um deles é a receita do Chef. Isso ajuda a configurar um servidor exclusivo usando Chef.

Método Woring

Precisamos ter Python e Git instalados no nó onde precisamos executar o blueprint.

Step 1 - Instale o blueprint.

vipin@server:~$ pip install blueprint

Step 2 - Crie um plano.

user@server:~$ sudo blueprint create internal-cookbook 
# [blueprint] using cached blueprintignore(5) rules 
# [blueprint] searching for Python packages 
# [blueprint] searching for PEAR/PECL packages 
# [blueprint] searching for Yum packages 
# [blueprint] searching for Ruby gems 
# [blueprint] searching for npm packages 
# [blueprint] searching for software built from source 
# [blueprint] searching for configuration files 
# [blueprint] /etc/ssl/certs/AC_Ra\xc3\xadz_Certic\xc3\ 
xa1mara_S.A..pem not UTF-8 - skipping it 
# [blueprint] /etc/ssl/certs/NetLock_Arany_=Class_Gold=_F\xc5\ 
x91tan\xc3\xbas\xc3\xadtv\xc3\xa1ny.pem not UTF-8 - skipping it 
# [blueprint] /etc/ssl/certs/EBG_Elektronik_Sertifika_Hizmet_Sa\ 
xc4\x9flay\xc4\xb1c\xc4\xb1s\xc4\xb1.pem not UTF-8 - skipping it 
# [blueprint] /etc/ssl/certs/Certinomis_-_Autorit\xc3\xa9_Racine. 
pem not UTF-8 - skipping it 
# [blueprint] /etc/ssl/certs/T\xc3\x9cB\xc4\xb0TAK_UEKAE_K\xc3\ 
xb6k_Sertifika_Hizmet_Sa\xc4\x9flay\xc4\xb1c\xc4\xb1s\xc4\xb1_-_S\ 
xc3\xbcr\xc3\xbcm_3.pem not UTF-8 - skipping it 
# [blueprint] searching for APT packages 
# [blueprint] searching for service dependencies

Step 3 - Crie um livro de receitas a partir da planta.

user@server:~$ blueprint show -C internal-cookbook my-server/recipes/default.rb

Step 4 - Valide o conteúdo do arquivo gerado.

user@server:~$ cat internal-cookbook /recipes/default.rb 
# 
# Automatically generated by blueprint(7). Edit at your own risk. 
# 
cookbook_file('/tmp/96468fd1cc36927a027045b223c61065de6bc575.tar') 
do 
   backup false 
   group 'root' 
   mode '0644' 
   owner 'root' 
   source 'tmp/96468fd1cc36927a027045b223c61065de6bc575.tar' 
end 
execute('/tmp/96468fd1cc36927a027045b223c61065de6bc575.tar') do 
   command 'tar xf "/tmp/96468fd1cc36927a027045b223c61065de6bc575.tar"' 
   cwd '/usr/local' 
end 
directory('/etc/apt/apt.conf.d') do 
...TRUNCATED OUTPUT... 
service('ssh') do 
   action [:enable, :start] 
   subscribes :restart, resources('cookbook_file[/etc/default/ 
      keyboard]', 'cookbook_file[/etc/default/console-setup]', 
      'cookbook_file[/etc/default/ntfs-3g]', 'package[openssh-server]', 
      'execute[96468fd1cc36927a027045b223c61065de6bc575.tar]') 
end

Script de Fluxo de Trabalho

Blueprint é um pacote Python que descobre todos os dados de configuração relevantes do servidor e os armazena em um repositório Git. Cada projeto tem seu próprio nome.

Pode-se pedir ao blueprint para mostrar o conteúdo de seu repositório Git em vários formantes.

user@server:~$ ls -l internal-cookbook / 
total 8 
drwxrwxr-x 3 vagrant vagrant 4096 Jun 28 06:01 files 
-rw-rw-r-- 1 vagrant vagrant 0 Jun 28 06:01 metadata.rb 
drwxrwxr-x 2 vagrant vagrant 4096 Jun 28 06:01 recipes

Blueprints Mostrar Comandos

user@server:~$ blueprint show-packages my-server 
...TRUNCATED OUTPUT... 
apt wireless-regdb 2011.04.28-1ubuntu3 
apt zlib1g-dev 1:1.2.3.4.dfsg-3ubuntu4 
python2.7 distribute 0.6.45 
python2.7 pip 1.3.1 
pip blueprint 3.4.2 
pip virtualenv 1.9.1

O comando anterior mostra todos os tipos de pacotes instalados. Outros comandos show são os seguintes -

  • show-files
  • show-services
  • show-sources

No Chef, a criação de arquivos de configuração e a movimentação de pacotes são os principais componentes. O Chef gerencia o mesmo de várias maneiras. O Chef suporta várias maneiras de lidar com arquivos e pacotes de software.

Instalando pacotes de repositório de terceiros

Step 1 - Edite a receita padrão do livro de receitas.

vipin@laptop:~/chef-repo $ subl cookbooks/test_cookbook/recipes/default.rb 
include_recipe "apt" 
apt_repository "s3tools" do 
   uri "http://s3tools.org/repo/deb-all" 
   components ["stable/"] 
   key "http://s3tools.org/repo/deb-all/stable/s3tools.key" 
   action :add 
end 
package "s3cmd"

Step 2 - Edite os metadados para adicionar dependência no livro de receitas do apt.

vipin@laptop:~/chef-repo $ subl cookbooks/my_cookbook/metadata.rb 
... 
depends "apt"

Step 3 - Carregue o livro de receitas modificado para o servidor Chef.

Step 4 - Valide se o pacote que você está tentando instalar ainda não está instalado.

Step 5 - Valide o repo padrão.

Step 6 - Execute Chef-Client no nó.

Step 7 - Valide se o pacote necessário está instalado.

Instalando o software da fonte

Se for necessário instalar um software que não está disponível como pacote para uma determinada plataforma, será necessário compilá-lo sozinho. No Chef, podemos fazer isso usando o recurso de script.

Step 1 - Edite a receita padrão.

vipin@laptop:~/chef-repo $ subl cookbooks/my_cookbook/recipes/ 
default.rb 
version = "1.3.9" 
bash "install_nginx_from_source" do 
   cwd Chef::Config['file_cache_path'] 
   code ≪-EOH 
      wget http://nginx.org/download/nginx-#{version}.tar.gz 
      tar zxf nginx-#{version}.tar.gz && 
      cd nginx-#{version} && 
      ./configure && make && make install 
   EOH

Step 2 - Carregue o livro de receitas modificado para o servidor Chef.

Step 3 - Execute o Chef-Client no nó.

Step 4 - Valide se o nginx está instalado.

Os livros de receitas da comunidade são semelhantes a qualquer outro livro de receitas. A única razão pela qual é chamado de livro de receitas da comunidade é porque qualquer pessoa que sabe escrever livros de receitas pode ingressar nesta comunidade e fazer upload de seus livros de receitas para o hub centralizado. Esses livros de receitas estão disponíveis gratuitamente e qualquer pessoa pode baixá-los e usá-los. Para usar esses livros de receitas da comunidade, é necessário baixá-los, modificá-los de acordo com os requisitos e carregá-los em seu respectivo servidor Chef.

É necessário ter a faca configurada em seu sistema para atualizar, fazer upload e baixar os livros de receitas. Interaja com livros de receitas usando os comandos do livro de receitas de faca. Com o livro de receitas da faca, você pode criar, excluir, mostrar, listar, baixar e carregar livros de receitas. Leia a documentação dos comandos do livro de receitas da faca para obter mais informações no Capítulo 7.

A seguir está o link dos livros de receitas da comunidade: https://supermarket.chef.io/cookbooksdirectory