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