Chef - Guida rapida

Chef è una tecnologia open source sviluppata da Opscode. Adam Jacob, co-fondatore di Opscode è conosciuto come il fondatore di Chef. Questa tecnologia utilizza la codifica Ruby per sviluppare elementi costitutivi di base come ricette e libri di cucina. Chef viene utilizzato nell'automazione dell'infrastruttura e aiuta a ridurre le attività manuali e ripetitive per la gestione dell'infrastruttura.

Chef ha una propria convenzione per diversi elementi costitutivi, necessari per gestire e automatizzare l'infrastruttura.

Perché Chef?

Chef è una tecnologia di gestione della configurazione utilizzata per automatizzare il provisioning dell'infrastruttura. È sviluppato sulla base del linguaggio Ruby DSL. Viene utilizzato per snellire l'attività di configurazione e gestione del server aziendale. Ha la capacità di integrarsi con qualsiasi tecnologia cloud.

In DevOps, utilizziamo Chef per distribuire e gestire server e applicazioni internamente e sul cloud.

Caratteristiche dello chef

Di seguito sono riportate le caratteristiche più importanti di Chef:

• Chef utilizza il popolare linguaggio Ruby per creare un linguaggio specifico del dominio.

• Chef non fa ipotesi sullo stato corrente di un nodo. Utilizza i suoi meccanismi per ottenere lo stato corrente della macchina.

• Chef è l'ideale per la distribuzione e la gestione del server cloud, dello storage e del software.

Vantaggi dello chef

Lo chef offre i seguenti vantaggi:

• Lower barrier for entry - Poiché Chef utilizza il linguaggio Ruby nativo per la configurazione, un linguaggio di configurazione standard può essere facilmente acquisito da chiunque abbia una certa esperienza di sviluppo.

• Excellent integration with cloud- Utilizzando l'utilità coltello, può essere facilmente integrato con qualsiasi tecnologia cloud. È lo strumento migliore per un'organizzazione che desidera distribuire la propria infrastruttura in ambiente multi-cloud.

Svantaggi di Chef

Alcuni dei principali svantaggi di Chef sono i seguenti:

• Uno degli enormi svantaggi di Chef è il modo in cui vengono controllati i libri di cucina. Ha bisogno di babysitter costante in modo che le persone che lavorano non debbano incasinare altri libri di cucina.

• È disponibile solo Chef solo.

• Nella situazione attuale, è adatto solo per il cloud AWS.

• Non è molto facile imparare se la persona non ha familiarità con Ruby.

• Manca ancora la documentazione.

Elementi fondamentali di Chef

Ricetta

Può essere definito come una raccolta di attributi che vengono utilizzati per gestire l'infrastruttura. Questi attributi presenti nella ricetta vengono utilizzati per modificare lo stato esistente o impostare un particolare nodo dell'infrastruttura. Vengono caricati durante l'esecuzione del client Chef e compartati con l'attributo esistente del nodo (macchina). Quindi arriva allo stato definito nella risorsa nodo della ricetta. È il principale cavallo di battaglia del libro di cucina.

Ricettario

Un libro di cucina è una raccolta di ricette. Sono gli elementi costitutivi di base che vengono caricati sul server Chef. Quando viene eseguita la corsa Chef, assicura che le ricette presenti al suo interno ottengano una data infrastruttura allo stato desiderato come elencato nella ricetta.

Risorsa

È il componente base di una ricetta utilizzata per gestire l'infrastruttura con diversi tipi di stati. Ci possono essere più risorse in una ricetta, che aiuteranno nella configurazione e nella gestione dell'infrastruttura. Ad esempio:

• package - Gestisce i pacchetti su un nodo

• service - Gestisce i servizi su un nodo

• user - Gestisce gli utenti sul nodo

• group - Gestisce i gruppi

• template - Gestisce i file con il modello Ruby incorporato

• cookbook_file - Trasferisce i file dalla sottodirectory files nel ricettario a una posizione sul nodo

• file - Gestisce il contenuto di un file sul nodo

• directory - Gestisce le directory sul nodo

• execute - Esegue un comando sul nodo

• cron - Modifica un file cron esistente sul nodo

Attributo

Sono fondamentalmente delle impostazioni. Possono essere pensati come una coppia di valori chiave di tutto ciò che si desidera utilizzare nel libro di cucina. Esistono diversi tipi di attributi che possono essere applicati, con un diverso livello di precedenza sulle impostazioni finali con cui opera il nodo.

File

È una sottodirectory all'interno del ricettario che contiene qualsiasi file statico che verrà posizionato sui nodi che utilizzano i libri di cucina. Una ricetta può quindi essere dichiarata come risorsa che sposta i file da quella directory al nodo finale.

Modelli

Sono simili ai file, ma non sono statici. I file modello terminano con l'estensione .ebr, il che significa che contengono Ruby incorporato. Sono principalmente utilizzati per sostituire un valore di attributo nei file per creare la versione finale del file che verrà posizionata sul nodo.

Metadata.rb

Viene utilizzato per gestire i metadati relativi al pacchetto. Ciò include dettagli come il nome e i dettagli del pacchetto. Include anche cose come le informazioni sulle dipendenze che dicono quali libri di cucina questo libro di cucina deve funzionare. Ciò consente al server Chef di costruire correttamente l'elenco di esecuzione del nodo e garantisce che tutti i pezzi vengano trasferiti correttamente.

Struttura predefinita del ricettario

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 - Tecnologie correlate

Di seguito è riportato l'elenco delle tecnologie correlate a Chef.

Fantoccio

Puppet fornisce un modo standard di fornire e utilizzare il software, indipendentemente da dove viene eseguito. È un motore amministrativo automatizzato per sistemi Linux, Unix e Windows che esegue attività amministrative basate su specifiche centralizzate.

Il primario features of Puppet sono i seguenti -

• Implementazione di nuovi sistemi con una configurazione uniforme.
• Aggiornamento dei sistemi e aggiornamento della sicurezza e dei pacchetti software.
• Incorporando nuove funzionalità e aggiungendo capacità abili.
• Personalizzazione delle configurazioni per garantire la disponibilità delle origini dati.
• Ottimizzazione delle risorse disponibili e riduzione al minimo dei costi.
• Semplificare i ruoli e consentire al team di concentrarsi su questioni fondamentali e produttive.
• Ottenere una vista a volo d'uccello dell'infrastruttura disponibile.

Ansible

Ansible è una piattaforma di automazione IT radicalmente semplice che semplifica la distribuzione delle applicazioni e dei sistemi. Evita di scrivere script o codice personalizzato per distribuire e aggiornare le tue applicazioni: automatizza in una lingua che si avvicina al semplice inglese, utilizzando SSH, senza agenti da installare su sistemi remoti.

Il primario features of Ansible sono i seguenti -

• Semplice e facile da imparare
• Scritto in Python
• Agentless
• Playbook basati su YAML
• Galassia Ansible

SaltStack

SaltStack viene utilizzato per la configurazione basata sui dati. È un nuovo approccio alla gestione dell'infrastruttura basato su bus di comunicazione dinamico. Viene utilizzato per l'orchestrazione basata sui dati, l'esecuzione remota per qualsiasi infrastruttura e la gestione della configurazione per qualsiasi stack di app.

Tessuto

Fabric è un linguaggio di programmazione basato su Python, sviluppato come API di Python che deve essere importato nel codice Python per configurare e gestire un'infrastruttura.

Chef lavora su un modello client server a tre livelli in cui le unità di lavoro come i libri di cucina vengono sviluppate sulla workstation Chef. Dalle utilità della riga di comando come il coltello, vengono caricate sul server Chef e tutti i nodi presenti nell'architettura vengono registrati con il server Chef.

Per mettere in atto l'infrastruttura di Chef funzionante, dobbiamo impostare più cose in sequenza.

Nella configurazione sopra, abbiamo i seguenti componenti.

Chef Workstation

Questa è la posizione in cui vengono sviluppate tutte le configurazioni. La workstation Chef è installata sulla macchina locale. La struttura di configurazione dettagliata è discussa nei capitoli successivi di questo tutorial.

Chef Server

Funziona come un'unità di lavoro centralizzata della configurazione di Chef, in cui tutti i file di configurazione vengono caricati dopo lo sviluppo. Esistono diversi tipi di server Chef, alcuni sono server Chef ospitato mentre altri sono premesse incorporate.

Nodi chef

Sono le macchine reali che verranno gestite dal server Chef. Tutti i nodi possono avere diversi tipi di configurazione secondo il requisito. Il client Chef è il componente chiave di tutti i nodi, che aiuta a impostare la comunicazione tra il server Chef e il nodo Chef. Gli altri componenti del nodo Chef è Ohai, che aiuta a ottenere lo stato corrente di qualsiasi nodo in un determinato momento.

L'utilizzo del sistema di controllo della versione è una parte fondamentale dell'automazione dell'infrastruttura. Esistono diversi tipi di sistemi di controllo della versione come SVN, CVS e GIT. A causa della popolarità di GIT tra la comunità di Chef, utilizzeremo la configurazione GIT.

Note - Non pensare di costruire un'infrastruttura come un codice senza un sistema di controllo della versione.

Su Windows

Step 1- Scarica il programma di installazione di Windows da www.git-scm.org e segui i passaggi di installazione.

Step 2 - Registrati per un repository centrale su GitHub.

Step 3- Carica la chiave ssh sull'account GitHub, in modo che si possa interagire facilmente con essa. Per i dettagli sulla chiave ssh, visitare il seguente collegamentohttps://help.github.com/articles/generatingssh-keys.

Step 4 - Infine, crea un repository sull'account GitHub visitando https://github.com/new con il nome di chef-repo.

Prima di iniziare effettivamente a scrivere un libro di cucina, è possibile impostare un repository GIT iniziale sulla scatola di sviluppo e clonare il repository vuoto fornito da Opscode.

Step 1 - Scarica la struttura vuota del repository Opscode Chef.

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

Step 2 - Estrai la palla di catrame.

$ tar –xvf master

Step 3 - Rinomina la directory.

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

Step 4 - Cambia la directory di lavoro corrente in chef repo.

$ cd chef-repo

Step 5 - Inizializza un nuovo repository get.

$ git init.

Step 6 - Connettiti al tuo repository sull'hub git.

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

Step 7 - Esegui il push del repository locale su GitHub.

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

Utilizzando la procedura sopra, si otterrà un repository chef vuoto. È quindi possibile iniziare a lavorare sullo sviluppo delle ricette e dei libri di cucina. Una volta terminato, puoi inviare le modifiche a GitHub.

Chef segue il concetto di architettura client-server, quindi per iniziare a lavorare con Chef è necessario impostare Chef sulla workstation e sviluppare la configurazione in locale. Successivamente può essere caricato sul server Chef per farli funzionare sui nodi Chef, che devono essere configurati.

Opscode fornisce una versione completamente pacchettizzata, che non ha prerequisiti esterni. Questo Chef completamente confezionato si chiamaomnibus installer.

Su macchina Windows

Step 1 - Scarica il file .msi di installazione di chefDK sulla macchina.

Step 2 - Segui i passaggi dell'installazione e installalo nella posizione di destinazione.

La configurazione apparirà come mostrato nello screenshot seguente.

Variabile di percorso ChefDK

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

Su macchina Linux

Per eseguire la configurazione sulla macchina Linux, dobbiamo prima ottenere curl sulla macchina.

Step 1 - Una volta che curl è installato sulla macchina, dobbiamo installare Chef sulla workstation utilizzando l'installer omnibus Chef di Opscode.

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

Step 2 - Installa Ruby sulla macchina.

Step 3 - Aggiungi Ruby alla variabile di percorso.

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

Omnibus Chef installerà Ruby e tutte le gemme Ruby richieste in /opt/chef/embedded aggiungendo /opt/chef/embedded/bin directory nel file .bash_profile.

Se Ruby è già installato, installa la gemma Chef Ruby sulla macchina eseguendo il seguente comando.

$ gem install chef

Per fare in modo che il nodo Chef comunichi con il server Chef, è necessario configurare il client Chef sul nodo.

Chef cliente

Questo è uno dei componenti chiave del nodo Chef, che recupera i libri di cucina dal server Chef e li esegue sul nodo. È anche noto come Provvisorio dello Chef.

Qui useremo Vagrant per gestire la VM. Vagrant può anche essere configurato con il provisioner come script Shell, Chef e Puppet per portare la VM nello stato desiderato. Nel nostro caso, utilizzeremo Vagrant per gestire le VM utilizzando VirtualBox e il client Chef come provisioner.

Step 1 - Scarica e installa VirtualBox da https://www.virtualbox.org/wiki/downlod

Step 2 - Scarica e installa Vagrant su http://downloads.vagrantup.com

Step 3 - Installa il plug-in Vagrant Omnibus per consentire a Vagrant di installare il client Chef sulla VM.

$ vagrant plugin install vagrant-omnibus

Creazione e avvio di Virtual

Step 1- Possiamo scaricare la scatola Vagrant richiesta dal repository vagrant Opscode. Scarica la casella opscode-ubuntu-12.04 dal seguente URLhttps://opscode-vmbento.s3.amazonaws.com/vagrant/opscode_ubuntu-12.04_provisionerless.box

Step 2 - Una volta ottenuto il file Vagrant, scarica il percorso necessario per modificare il file 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

Nel programma precedente, è necessario aggiornare il nome <YOUR_ORG> con il nome dell'organizzazione corretto o richiesto.

Step 3- Il prossimo passo dopo la configurazione è, per ottenere la scatola vagabonda. Per questo, devi spostarti nella posizione in cui si trova la casella Vagrant ed eseguire il seguente comando.

$ vagrant up

Step 4 - Una volta che la macchina è attiva, puoi accedere alla macchina utilizzando il seguente comando.

$ vagrant ssh

Nel comando precedente, vagrantfile è scritto in un Ruby Domain Specific Language (DSL) per la configurazione della macchina virtuale vagrant.

Nel file vagrant, abbiamo l'oggetto config. Vagrant utilizzerà questo oggetto di configurazione per configurare la VM.

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

All'interno del blocco di configurazione, dirai a vagrant quale immagine VM usare, per avviare il nodo.

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

Nel passaggio successivo, dirai a Vagrant di scaricare il plug-in omnibus.

config.omnibus.chef_version = :latest

Dopo aver selezionato la casella VM da avviare, configurare come eseguire il provisioning della casella utilizzando Chef.

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

All'interno di questo, è necessario impostare le istruzioni su come collegare il nodo virtuale al server Chef. Devi dire a Vagrant dove devi memorizzare tutte le cose di Chef sul nodo.

chef.provisioning_path = "/etc/chef"

Test Kitchen è il framework di test integrato di Chef. Consente la scrittura di ricette di test, che verranno eseguite sulle VM una volta che sono state istanziate e convertite utilizzando il ricettario. Le ricette di test vengono eseguite su quella VM e possono verificare se tutto funziona come previsto.

ChefSpecè qualcosa che simula solo una corsa dello chef. Prova la cucina avvia il nodo reale e ci fa girare Chef.

Step 1 - Installa la gemma Ruby della cucina di prova e la gemma vagabonda della cucina di prova per consentire alla cucina di prova di utilizzare vagrant per il test di rotazione.

$ gem install kitchen 
$ gem install kitchen-vagrant

Step 2- Prepara una cucina di prova. Questo può essere fatto creando.kitchen.yml nella directory del ricettario.

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!'} }

Nel codice sopra, una parte definisce che vagrant deve avviare le VM e definisce che si desidera che Omnibus installi Chef sul nodo di destinazione.

La seconda parte definisce su quale piattaforma si desidera testare i libri di cucina. Vagrant creerà e distruggerà sempre nuove istanze. Non devi temere gli effetti collaterali delle VM vagabonde che fai girare usando il file Vagrant.

La cucina di prova può essere considerata un ambiente temporaneo che aiuta a eseguire e testare libri di cucina in un ambiente temporaneo simile alla produzione. Con la cucina di prova attiva, è possibile assicurarsi che il pezzo di codice dato funzioni, prima che venga effettivamente distribuito nell'ambiente di test, preproduzione e produzione. Questa caratteristica della cucina di prova è seguita da molte organizzazioni come set prima di inserire i libri di cucina in un ambiente di lavoro reale.

Prova il flusso di lavoro della cucina

Di seguito sono riportati i passaggi coinvolti nel flusso di lavoro Test Kitchen.

Creazione di un libro di cucina utilizzando Chef

Usa il codice seguente per creare un libro di cucina.

$ 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"

Di seguito è riportata la struttura del libro di cucina creato come output del codice precedente.

File di configurazione della cucina di prova

File .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 - Specifica il software che gestisce la macchina.

Provisioner- Fornisce le specifiche su come funziona Chef. Stiamo usando chef_zero perché consente di imitare un ambiente server Chef sulla macchina locale. Ciò consente di lavorare con gli attributi del nodo e le specifiche del server Chef.

Platform - Specifica il sistema operativo di destinazione.

Suites- Definisce cosa si vuole applicare all'ambiente virtuale. Qui si definiscono più definizioni. È la posizione in cui si definisce l'elenco di esecuzione, che specifica quale ricetta eseguire e in quale sequenza dobbiamo eseguire.

Esecuzione dei comandi in sequenza

Lista della cucina

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

Cucina Crea

$ 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)

Cucina 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)

Configurazione di prova

L'accesso alla cucina viene utilizzato per verificare se il provisioning della VM di prova è corretto.

$ 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

Infine esci

$ exit 
Logout 
Connection to 127.0.0.1 closed.

Distruggere l'installazione

$ 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 è lo strumento della riga di comando di Chef per interagire con il server Chef. Uno lo usa per caricare libri di cucina e gestire altri aspetti di Chef. Fornisce un'interfaccia tra chefDK (Repo) sulla macchina locale e il server Chef. Aiuta a gestire -

• Nodi chef
• Cookbook
• Recipe
• Environments
• Risorse cloud
• Provisioning cloud
• Installazione su client Chef su nodi Chef

Knife fornisce una serie di comandi per gestire l'infrastruttura di Chef.

Comandi Bootstrap

• coltello bootstrap [SSH_USER @] FQDN (opzioni)

Comandi client

• coltello client eliminazione in blocco REGEX (opzioni)
• client knife crea CLIENTNAME (opzioni)
• coltello client elimina CLIENTE (opzioni)
• coltello client modifica CLIENTE (opzioni)
• Utilizzo: C: / opscode / chef / bin / knife (opzioni)
• coltello chiave client cancella NOME CHIAVE CLIENTE (opzioni)
• modifica chiave client coltello NOME CHIAVE CLIENTE (opzioni)
• elenco chiavi client coltello CLIENTE (opzioni)
• chiave client coltello mostra NOME CHIAVE CLIENTE (opzioni)
• lista clienti coltello (opzioni)
• cliente di coltello registra nuovamente CLIENTE (opzioni)
• client coltello mostra CLIENTE (opzioni)

Configura comandi

• configurazione coltello (opzioni)
• coltello configura client DIRECTORY

Comandi del libro di cucina

• coltello ricettario eliminazione in blocco REGEX (opzioni)
• ricettario coltello creare RICETTARIO (opzioni)
• coltello ricettario cancella VERSIONE RICETTARIO (opzioni)
• download del ricettario del coltello COOKBOOK [VERSION] (opzioni)
• elenco ricettario coltelli (opzioni)
• coltello ricettario metadati ricettario (opzioni)
• metadati del ricettario del coltello da FILE (opzioni)
• libro di cucina con coltelli mostra COOKBOOK [VERSION] [PART] [FILENAME] (opzioni)
• test del ricettario del coltello [RICETTARI ...] (opzioni)
• caricamento ricettario coltello [RICETTARI ...] (opzioni)

Comandi del sito del ricettario

• sito di ricettario coltello scarica COOKBOOK [VERSION] (opzioni)
• sito di ricettario coltello installazione COOKBOOK [VERSION] (opzioni)
• elenco dei siti del ricettario del coltello (opzioni)
• ricerca nel sito di ricettario coltello QUERY (opzioni)
• sito di ricettario coltello condivisione COOKBOOK [CATEGORIA] (opzioni)
• sito di ricettario coltello mostra COOKBOOK [VERSION] (opzioni)
• sito di ricettario coltello unshare COOKBOOK

Comandi Data Bag

• borsa dati coltello crea BORSA [ARTICOLO] (opzioni)
• sacchetto dati coltello elimina BAG [ITEM] (opzioni)
• borsa dati coltello modifica ARTICOLO BORSA (opzioni)
• sacchetto dati coltello da file BAG FILE | FOLDER [FILE | FOLDER ..] (opzioni)
• lista dei sacchetti dei dati dei coltelli (opzioni)
• borsa dati coltello mostra BAG [ITEM] (opzioni)

Comandi ambientali

• confronto ambiente coltello [AMBIENTE ..] (opzioni)
• l'ambiente del coltello crea AMBIENTE (opzioni)
• coltello ambiente elimina AMBIENTE (opzioni)
• ambiente coltello modifica AMBIENTE (opzioni)
• ambiente coltello dal file FILE [FILE ..] (opzioni)
• lista ambiente coltello (opzioni)
• coltello ambiente mostra AMBIENTE (opzioni)

Comandi di esecuzione

• coltello exec [SCRIPT] (opzioni)

Comandi di aiuto

• aiuto coltello [elenco | ARGOMENTO]

Comandi di indice

• ricostruzione indice coltello (opzioni)

Comandi del nodo

• Nodo coltello eliminazione in blocco REGEX (opzioni)
• nodo coltello crea NODO (opzioni)
• Knife Knife cancella NODE (opzioni)
• modifica nodo coltello NODE (opzioni)
• ambiente nodo coltello impostato NODE ENVIRONMENT
• nodo coltello dal file FILE (opzioni)
• elenco dei nodi dei coltelli (opzioni)
• Knife Knife run_list aggiungi [NODE] [ENTRY [, ENTRY]] (opzioni)
• Knife node run_list rimuovi [NODE] [ENTRY [, ENTRY]] (opzioni)
• Knife Knife run_list set NODE ENTRIES (opzioni)
• nodo coltello mostra NODE (opzioni)

Comandi OSC

• coltello osc_user crea UTENTE (opzioni)
• coltello osc_user elimina USER (opzioni)
• coltello osc_user modifica USER (opzioni)
• coltello osc_user list (opzioni)
• coltello osc_user registra nuovamente USER (opzioni)
• coltello osc_user mostra USER (opzioni)

Comandi basati sul percorso

• coltello elimina [PATTERN1 ... PATTERNn]
• Knife deps PATTERN1 [PATTERNn]
• MODELLI diff. coltello
• coltello scarica PATTERNS
• modifica coltello [PATTERN1 ... PATTERNn]
• lista coltelli [-dfR1p] [PATTERN1 ... PATTERNn]
• spettacolo di coltelli [PATTERN1 ... PATTERNn]
• modelli di caricamento del coltello
• coltello xargs [COMANDO]

Comandi grezzi

• coltello grezzo REQUEST_PATH

Comandi delle ricette

• elenco delle ricette del coltello [PATTERN]

Comandi di ruolo

• coltello ruolo eliminazione collettiva REGEX (opzioni)
• ruolo coltello crea RUOLO (opzioni)
• coltello ruolo cancella RUOLO (opzioni)
• coltello ruolo modifica RUOLO (opzioni)
• knife role env_run_list add [ROLE] [ENVIRONMENT] [ENTRY [, ENTRY]] (opzioni)
• ruolo coltello env_run_list clear [ROLE] [ENVIRONMENT]
• ruolo coltello env_run_list rimuovi [ROLE] [ENVIRONMENT] [ENTRIES]
• ruolo coltello env_run_list sostituisci [ROLE] [ENVIRONMENT] [OLD_ENTRY] [NEW_ENTRY]
• set di ruoli coltello env_run_list [ROLE] [ENVIRONMENT] [ENTRIES]
• ruolo coltello dal file FILE [FILE ..] (opzioni)
• elenco ruoli coltello (opzioni)
• ruolo coltello run_list aggiungi [ROLE] [ENTRY [, ENTRY]] (opzioni)
• ruolo coltello run_list clear [ROLE]
• ruolo coltello run_list rimuovi [ROLE] [ENTRY]
• ruolo coltello run_list sostituisci [ROLE] [OLD_ENTRY] [NEW_ENTRY]
• ruolo coltello run_list impostato [ROLE] [ENTRIES]
• coltello ruolo spettacolo RUOLO (opzioni)

Servire i comandi

• servizio coltello (opzioni)

Comandi SSH

• knife ssh QUERY COMMAND (opzioni)

Comandi SSL

• knife ssl check [URL] (opzioni)
• coltello ssl fetch [URL] (opzioni)

Comandi di stato

• stato coltello QUERY (opzioni)

Comandi tag

• tag coltello crea NODE TAG ...
• coltello tag cancella NODE TAG ...
• tag list coltello NODE

Comandi utente

• utente coltello crea USERNAME DISPLAY_NAME FIRST_NAME LAST_NAME EMAIL PASSWORD (opzioni)
• coltello utente elimina USER (opzioni)
• coltello utente modifica USER (opzioni)
• chiave utente coltello crea UTENTE (opzioni)
• coltello chiave utente cancella USER KEYNAME (opzioni)
• coltello chiave utente modifica USER KEYNAME (opzioni)
• elenco chiavi utente coltello USER (opzioni)
• chiave utente coltello mostra USER KEYNAME (opzioni)
• elenco utenti coltello (opzioni)
• coltello utente registra nuovamente USER (opzioni)
• coltello utente mostra USER (opzioni)

Configurazione del coltello

Per impostare il coltello, è necessario passare a .chef directory e creare un file knife.rball'interno del repo dello chef, che racconta al coltello i dettagli della configurazione. Questo avrà un paio di dettagli.

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"]

Nel codice sopra, stiamo usando il server Chef ospitato che utilizza le seguenti due chiavi.

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

Qui, knife.rb dice al coltello quale organizzazione usare e dove trovare la chiave privata. Indica al coltello dove trovare la chiave privata degli utenti.

client_key               "#{current_dir}/USER.pem"

La seguente riga di codice dice al coltello che stiamo usando il server ospitato.

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

Utilizzando il file knife.rb, il coltello validatore può ora connettersi all'Opscode ospitato dalla tua organizzazione.

Chef-Solo è uno strumento open source che viene eseguito localmente e consente di eseguire il provisioning delle macchine ospiti utilizzando i libri di cucina di Chef senza la complicazione di alcuna configurazione di client e server Chef. Aiuta a eseguire libri di cucina su un server auto-creato.

Prima di eseguire Chef-Solo sulla macchina locale, è necessario installare i seguenti due file sulla macchina locale.

• Solo.rb - Questo file indica a Chef dove trovare libri di cucina, ruoli e sacchetti di dati.

• Node.json - Questo file imposta l'elenco delle esecuzioni e qualsiasi attributo specifico del nodo, se richiesto.

Configurazione solo.rb

Di seguito sono riportati i passaggi per configurare solo.rb.

Step 1 - Crea un file solo.rb all'interno del repository chef.

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 - Aggiungi il file a git repo.

$ git add solo.rb

Step 3 - Crea un file node.json all'interno del repository chef con il seguente contenuto.

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

Step 4 - Prendi il ricettario ntp all'interno del repository chef usando il coltello.

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 - Aggiungi il file node.json a Git.

$ git add node.json

Step 6 - Eseguire il commit e il push dei file in 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

Esecuzione del ricettario su Node

Step 1 - Accedi al nodo in cui si desidera fornire lo Chef-Solo.

Step 2 - Clona il repository Chef sulla macchina.

$ git clone $URL_PATH

Step 3 - cd al repo dello chef.

$ cd chef-repo

Infine, esegui Chef-Solo per far convergere il nodo -

$ 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 per cercare i suoi libri di cucina, ruoli e contenitori di dati all'interno della directory corrente: il repository Chef.

Chef-Soloprende la configurazione del nodo da un file JSON. Nel nostro esempio, l'abbiamo chiamato node.json. Se intendi gestire più server, avrai bisogno di un file separato per ogni nodo. Quindi, Chef-Solo esegue semplicemente un'esecuzione Chef in base ai dati di configurazione trovati in solo.rb e node.json.

I libri di cucina sono unità di lavoro fondamentali di Chef, che consistono in tutti i dettagli relativi alle unità di lavoro, avendo la possibilità di modificare la configurazione e lo stato di qualsiasi sistema configurato come nodo dell'infrastruttura di Chef. I libri di cucina possono eseguire più attività. I libri di cucina contengono valori sullo stato desiderato del nodo. Ciò si ottiene in Chef utilizzando le librerie esterne desiderate.

Componenti chiave di un libro di cucina

• Recipes
• Metadata
• Attributes
• Resources
• Templates
• Libraries
• Qualsiasi altra cosa che aiuti a creare un sistema

Creazione di un libro di cucina

Esistono due modi per creare dinamicamente un libro di cucina.

• Usando il comando dello chef
• Usando l'utilità del coltello

Utilizzo del comando Chef

Per creare un ricettario vuoto utilizzando il comando Chef, eseguire il comando seguente.

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)

La struttura del ricettario con il nome VTest verrà creata nella directory e di seguito sarà la struttura per lo stesso.

Utilizzo di Knife Utility

Usa il seguente comando per creare un libro di cucina usando l'utilità coltello.

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

Di seguito la struttura del ricettario.

Le caratteristiche di definizione delle dipendenze del libro di cucina aiutano nella gestione del libro di cucina. Questa funzione viene utilizzata quando si desidera utilizzare la funzionalità di un libro di cucina in altri libri di cucina.

Ad esempio, se si desidera compilare codice C, è necessario assicurarsi che tutte le dipendenze richieste per la compilazione siano installate. Per fare ciò, potrebbe esserci un libro di cucina separato in grado di eseguire tale funzione.

Quando utilizziamo chef-server, dobbiamo conoscere tali dipendenze nei libri di cucina che dovrebbero essere decelerate nel file di metadati dei libri di cucina. Questo file si trova nella parte superiore della struttura della directory del ricettario. Fornisce suggerimenti al server Chef che aiuta a distribuire libri di cucina sul nodo corretto.

Caratteristiche del file metadata.rb

• Situato nella parte superiore della struttura della directory del ricettario.

• Compilato quando il ricettario viene caricato sul server Chef utilizzando il comando coltello.

• Compilato con il sottocomando dei metadati del ricettario del coltello.

• Creato automaticamente quando viene eseguito il comando di creazione del ricettario del coltello.

Configurazione di metadata.rb

Di seguito è riportato il contenuto predefinito di un file di metadati.

I ruoli in Chef sono un modo logico di raggruppare i nodi. I casi tipici prevedono ruoli per server Web, server di database e così via. È possibile impostare un elenco di esecuzione personalizzato per tutti i nodi e sovrascrivere il valore dell'attributo all'interno dei ruoli.

Crea un ruolo

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 
   } 
}

Una volta creato il ruolo, dobbiamo caricarlo sul server Chef.

Carica ruolo su Chef Server

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

Ora, dobbiamo assegnare un ruolo a un nodo chiamato server.

Assegna un ruolo a Node

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

Esegui lo 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...

Come funziona

• Definisci un ruolo in un file Ruby all'interno della cartella dei ruoli del repository Chef.

• Un ruolo è costituito da un nome e da un attributo di descrizione.

• Un ruolo è costituito da un elenco di esecuzione specifico del ruolo e dalle impostazioni degli attributi specifici del ruolo.

• Ogni nodo che ha un ruolo nel proprio elenco di esecuzione avrà l'elenco di esecuzione del ruolo imposto nel proprio.

• Tutte le ricette nell'elenco di esecuzione del ruolo verranno eseguite sul nodo.

• Il ruolo verrà caricato sul server Chef utilizzando il comando Knife role from file.

• Il ruolo verrà aggiunto all'elenco di esecuzione dei nodi.

• L'esecuzione del client Chef su un nodo che ha il ruolo nella sua run list eseguirà tutte le ricette elencate nel ruolo.

Lo chef aiuta a eseguire la configurazione specifica dell'ambiente. È sempre una buona idea avere un ambiente separato per lo sviluppo, il test e la produzione.

Chef consente di raggruppare i nodi in ambienti separati per supportare un flusso di sviluppo ordinato.

Creare un ambiente

La creazione dell'ambiente al volo può essere eseguita utilizzando l'utilità del coltello. Il seguente comando aprirà un editor predefinito di Shell, in modo da poter modificare la definizione dell'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

Testare un ambiente creato

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

List Node for All Environments

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

_default Environment

Ogni organizzazione inizierà sempre con almeno un unico ambiente denominato ambiente predefinito, che è sempre disponibile per il server Chef. Un ambiente predefinito non può essere modificato in alcun modo. Qualsiasi tipo di modifica può essere adattata solo all'ambiente personalizzato che creiamo.

Attributi ambientali

Un attributo può essere definito in un ambiente e quindi utilizzato per sovrascrivere le impostazioni predefinite nel nodo. Quando viene eseguita l'esecuzione del client Chef, questi attributi vengono confrontati con gli attributi predefiniti già presenti nel nodo. Quando gli attributi dell'ambiente hanno la precedenza sugli attributi predefiniti, il client Chef applicherà queste impostazioni e questi valori quando l'esecuzione del client Chef avviene su ogni nodo.

Un attributo di ambiente può essere solo default_attribute o override_attribute. Non può essere un attributo normale. Si possono usare i metodi default_attribute o override_attribute.

Tipo di attributo

Default - Un attributo predefinito viene sempre ripristinato all'inizio di ogni esecuzione del client Chef e ha la precedenza dell'attributo più bassa.

Override- Un attributo di override viene sempre reimpostato all'inizio di ogni esecuzione del client Chef e ha una precedenza dell'attributo superiore a quella predefinita, force_default e normale. Un attributo di sostituzione viene spesso definito nella ricetta ma può anche essere specificato in un file di attributi per un ruolo o per un ambiente.

Ordine di applicazione di un attributo

L'esecuzione di Chef-Client come daemon aiuta a conoscere lo stato di tutti i nodi in qualsiasi momento. Questo aiuta a far funzionare lo Chef-Client in qualsiasi momento.

Prerequisiti

Il nodo dovrebbe essere registrato con il server Chef e dovrebbe essere in esecuzione Chef-Client senza errori.

Chef-Client in modalità Daemon

Avvia Chef-Client in modalità demone, in esecuzione ogni 30 minuti.

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

Nel codice sopra, - i consente di eseguire Chef-Client in modalità daemon sul nodo richiesto e 1800 secondi definiscono che il daemon Chef-Client deve essere eseguito ogni 30 minuti.

Convalida di Daemon Run

Convalida che Chef-Client sia in esecuzione come daemon.

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

Il comando precedente eseguirà il grep del processo daemon in esecuzione di Chef-Client.

Altri modi

Invece di eseguire Chef-Client come daemon, possiamo eseguire lo stesso come un 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'

Il cron job di cui sopra verrà eseguito ogni 15 minuti.

Scrivere libri di cucina per Chef è sempre difficile. Rende ancora più difficile a causa del lungo ciclo di feedback di caricarli sul server Chef, eseguire il provisioning di una VM vagabonda, controllare come hanno fallito lì, risciacquare e ripetere. Sarebbe più facile se potessimo provare a testare alcuni pezzi o ricette prima di fare tutto questo lavoro pesante in una volta.

Chef viene fornito con Chef-Shell, che è essenzialmente una sessione Ruby interattiva con Chef. In Chef-Shell, possiamo creare -

• Attributes
• Scrivi ricette
• L'inizializzazione di Chef viene eseguita

Viene utilizzato per valutare parti di ricette al volo, prima di caricarle sul server Chef ed eseguire libri di cucina completi sul nodo.

Esecuzione di Shell

Step 1 - Esegui Chef-Shell in modalità standalone.

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 - Passa alla modalità attributo in Chef-Shell

• chef > attributes_mode

Step 3 - Impostazione del valore dell'attributo.

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

  • "Chef Cookbook"

• chef:attributes > quit

  • :attributes

• chef >

Step 4 - Passa alla modalità ricetta.

• chef > recipe_mode

Step 5 - Crea una risorsa file.

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 - Comincia la corsa di Chef per creare il file con il contenuto dato.

• 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

Come funziona

• Chef-Shell inizia con una sessione Interactive Ruby (IRB) migliorata con alcune funzionalità specifiche.

• Offre modalità come attributes_mode e interactive_mode.

• Aiuta a scrivere i comandi, che vengono scritti all'interno di una ricetta o di un libro di cucina.

• Funziona tutto in una modalità interattiva.

Possiamo eseguire Chef-Shell in tre diverse modalità: Standalone mode, Client mode, e Solo mode.

• Standalone mode- È la modalità predefinita. Nessun libro di cucina viene caricato e l'elenco di esecuzione è vuoto.

• Client mode - Qui, lo chef-shell funge da chef-cliente.

• Solo mode - Qui, lo chef-shell funge da cliente chef-solista.

Nel caso in cui il libro di cucina venga distribuito direttamente ed eseguito sul server di produzione, ci sono alte probabilità che il libro di cucina possa interrompersi durante la produzione. Il modo migliore per evitare che ciò accada è testare il ricettario nell'ambiente di configurazione.

Di seguito sono riportati i passaggi per il test.

Step 1 - Installa il ricettario utilizzando il seguente comando.

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

Step 2 - Eseguire i comandi di test del ricettario del coltello sul ricettario funzionante.

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

Step 3 - Rompi qualcosa nel ricettario e riprova.

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 - Eseguire nuovamente il comando di prova del coltello.

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:

Metodo di lavoro

Knife cookbook test esegue un controllo della sintassi Ruby su tutti i file Ruby all'interno del ricettario e su tutti i modelli ERB. Passa attraverso i file Ruby ed esegue Ruby–ccontro ciascuno di loro. Rubino–c controlla la sintassi dello script e si chiude senza eseguirlo.

Dopo aver esaminato tutti i file Ruby, il test del ricettario del coltello passa attraverso tutti i modelli e le pipe ERB, la versione ridondante creata da –x attraverso Ruby –c.

Limitazioni

Knife cookbook test esegue solo un semplice controllo della sintassi sui file Ruby e sui modelli ERB. Possiamo andare avanti completamente test driven utilizzando ChefSpec e test kitchen.

Scrivere buoni libri di cucina senza problemi è un compito abbastanza difficile. Ma ci sono modi che possono aiutare a identificare le insidie. È possibile contrassegnare in Chef Cookbook. Foodcritic è uno dei modi migliori per archiviarlo, che cerca di identificare possibili problemi con la logica e lo stile dei libri di cucina.

Configurazione Foodcritic

Step 1 - Aggiungi gemma Foodcritic.

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

Step 2 - Installa la gemma.

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

Gemma critica al cibo

Step 1 - Esegui Foodcritic sul ricettario.

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 - Genera un rapporto dettagliato.

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|

Metodo di lavoro

Foodcritic definisce un insieme di regole e controlla gli agenti delle ricette, ciascuno di essi. Viene fornito con più regole riguardanti varie aree: stili, connessione, attributi, stringa, probabilità, ricerca, servizi, file, metadati e così via.

Test Driven Development (TDD)è un modo per scrivere un test unitario prima di scrivere qualsiasi codice ricetta effettivo. Il test dovrebbe essere reale e dovrebbe convalidare ciò che fa una ricetta. In realtà dovrebbe fallire perché non è stata sviluppata alcuna ricetta. Una volta sviluppata la ricetta, il test dovrebbe passare.

ChefSpec si basa sul popolare framework RSpec e offre una sintassi su misura per testare la ricetta di Chef.

Creazione di ChefSpec

Step 1 - Crea un file gem contenente la gemma chefSpec.

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

Step 2 - Installa la gemma.

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 - Crea una directory specifica.

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

Step 4 - Crea una specifica

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 - Convalida 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 - Modifica ricetta predefinita dei libri di cucina.

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

Step 7 - Crea un file modello.

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

Step 8 - Esegui di nuovo rspec.

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

Come funziona

Per farlo funzionare, dobbiamo prima configurare l'infrastruttura di base per l'utilizzo di RSpec con Chef. Quindi abbiamo bisogno di ChefSpec Ruby gem e il ricettario ha bisogno di una directory chiamata spec in cui verranno salvati tutti i test.

La cucina di prova è il framework di test di integrazione di Chef. Abilita i test di scrittura, che vengono eseguiti dopo che la VM è stata istanziata e convertita utilizzando il ricettario. I test vengono eseguiti su VM e possono verificare che tutto funzioni come previsto.

Questo è il contratto nodo per ChefSpec, che simula solo una corsa Chef. Test Kitchen avvia un nodo reale e ci esegue Chef.

Impostare

Per fare ciò, dobbiamo avere Vagrant installato sulla macchina che aiuta nella gestione di una macchina virtuale. Quindi dobbiamo avere la libreria installata e agganciata a Vagrant per gestire le dipendenze dei libri di cucina.

Step 1 - Modifica la ricetta predefinita nel ricettario.

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

Step 2 - Modifica gli attributi del libro di cucina.

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

Step 3 - Modifica il file gem per installare le gemme Ruby necessarie.

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

Step 4 - Installa la gemma Ruby necessaria.

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 - Crea il file .kitchen.yml nel ricettario.

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 - Crea una directory di test all'interno del ricettario.

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

Step 7 - Creare un libro di cucina di prova per i test di integrazione.

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 - Modifica la ricetta predefinita dei libri di cucina di prova.

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

Step 9 - Crea Minitest Spec all'interno del ricettario.

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 - Modifica il Berksfile del tuo libro di cucina principale.

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"

Testare l'installazione

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 i dettagli su tutti i nodi che utilizzano un determinato libro di cucina prima di caricarlo sul server Chef.

Iniziare

Per iniziare, è necessario che sia installata una gemma di preflight con coltello.

Step 1 - Definisci il percorso nel file gem.

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

Step 2 - Esegui bundler per installare gemma di preflight coltello.

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

Metodo di lavoro

Esegui il preflight del coltello sul ricettario fornito.

Possiamo eseguire il comando di verifica preliminare per scoprire quali nodi e ruoli hanno il ricettario dato nelle loro liste di esecuzione espanse.

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

Esistono diversi modi per eseguire un libro di cucina sul nodo.

• È possibile assegnare il libro di cucina direttamente a un nodo aggiungendolo all'elenco di esecuzione del nodo.

• È possibile aggiungere un libro di cucina al ruolo e aggiungere il ruolo all'elenco di esecuzione del nodo.

• È possibile aggiungere il ruolo all'elenco di esecuzione di un altro ruolo e aggiungere quell'altro ruolo all'elenco di esecuzione del nodo.

• Un libro di cucina può essere una dipendenza di un altro libro di cucina usato.

Indipendentemente dal modo in cui un libro di cucina finisce nell'elenco di esecuzione di un nodo, il comando di verifica preliminare del coltello lo catturerà poiché Chef memorizza tutti gli elenchi espansi di ruoli e ricette negli attributi del nodo. Il comando di verifica preliminare del coltello esegue una ricerca per esattamente quegli attributi del nodo.

Per testare l'esecuzione di Chef-Client, è necessario che Chef-Client sia configurato per utilizzare lo Chef ospitato o il proprio server ospitato.

Esecuzione di Chef-Client in modalità debug

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

Ispezione del risultato dell'ultima esecuzione Chef-Client

Al fine di controllare l'ultima esecuzione di Chef-Client, in particolare i problemi di fallimento quando stiamo sviluppando un nuovo libro di cucina, dobbiamo sapere cosa è andato storto esattamente. Anche se Chef stampa tutto in stdout, si potrebbe voler vedere di nuovo il registro di debug.

Se vogliamo testare, dobbiamo avere un libro di cucina rotto che non riesce a compilare.

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:

Per maggiori dettagli, possiamo esaminare lo 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'

Gli attributi sono i componenti chiave per configurare dinamicamente i libri di cucina. Gli attributi consentono agli autori di rendere configurabile il ricettario. Sovrascrivendo i valori predefiniti impostati nei libri di cucina, l'utente può inserire i propri valori.

Step 1 - Creare un file predefinito per gli attributi del libro di cucina e aggiungervi un attributo predefinito.

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

Step 2 - Definisci l'attributo all'interno della ricetta.

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 - Caricamento del ricettario modificato.

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

Step 4 - Esecuzione di Chef-Client del nodo definito.

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...

Metodo di lavoro

Chef carica tutti gli attributi dal file degli attributi prima di eseguirli. Gli attributi vengono memorizzati con l'oggetto nodo. È possibile accedere a tutti gli attributi memorizzati con l'oggetto nodo all'interno delle ricette e recuperare i loro valori correnti.

Chef ha una struttura limitata a partire dal valore predefinito che è il più basso, quindi diventa normale (che è alias con il set) e quindi sostituisce. Il livello di attributo impostato nella ricetta ha la precedenza sullo stesso livello impostato in un file di attributi.

Sostituzione dell'attributo a livello di nodo e ambiente

Gli attributi definiti nei ruoli o nell'ambiente hanno la massima precedenza.

Step 1 - Crea un ruolo.

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 - Carica il ruolo sul server Chef.

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

Step 3 - Assegna il ruolo a un nodo.

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

Step 4 - Esegui lo 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...

Infrastruttura, configuration managementè tutto su come si configurano bene gli host. In generale, tutte le configurazioni vengono eseguite utilizzando i file di configurazione. Chef utilizza i modelli per poter riempire il file di configurazione con valori dinamici.

Lo chef fornisce modelli come risorsa che può essere utilizzata nella ricetta. I valori dinamici dei file di configurazione possono essere recuperati da sacchi di dati, attributi o persino calcolarli passandoli nel modello.

Come usarlo?

Step 1 - Aggiungi il modello alla ricetta.

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 - Aggiungi ERB File modello.

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

Step 3 - Carica il ricettario modificato sul server 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 - Convalida il contenuto del file caricato.

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!

Flusso di lavoro

Lo chef utilizza Erubis come linguaggio del modello. Permette di incorporare il codice Ruby puro all'interno di simboli speciali nei template.

• <% =%> viene utilizzato se si desidera stampare il valore di una variabile o di un'espressione Ruby nel file generato.

• <% -%> è usato se vuoi incorporare la logica Ruby nel tuo file modello. Lo usiamo per ripetere la nostra espressione quattro volte.

In Chef, se è necessario creare ricette semplici, è possibile utilizzare le risorse disponibili in Chef, come modelli, file_remoto e servizi. Tuttavia, man mano che le ricette diventano elaborate, sono necessarie tecniche avanzate, come le istruzioni condizionali per eseguire parti della ricetta a condizione. Questo è il potere di mescolare il semplice Ruby con il linguaggio DSL (Chef Domain Specific Language).

Come usarlo?

Avvia Chef Shell su uno qualsiasi dei nodi in modalità client per poter accedere al server 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>

Condizioni di base con Chef DSL

Ordina i nodi per nome usando il semplice Ruby.

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

Esegui il ciclo attraverso i nodi, stampando il loro sistema operativo.

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

Installa più gemme Ruby usando un array, un loop e l'espansione di stringhe per costruire i nomi delle gemme.

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

Metodo di lavoro

Le ricette di Chef sono file Ruby, che vengono valutati nel contesto di Chef run. Possono contenere codice Ruby semplice come istruzione if e loop, nonché elementi DSL di Chef come le risorse.

All'interno della ricetta, si può semplicemente dichiarare le variabili Ruby e assegnarle dei valori.

Le ricette sono gli elementi costitutivi chiave del libro di cucina che è fondamentalmente codice Ruby. È possibile utilizzare tutte le funzionalità del linguaggio Ruby all'interno della ricetta dello Chef. La maggior parte delle volte la funzionalità incorporata in Ruby è sufficiente, ma a volte potrebbe essere necessario utilizzare gemme Ruby aggiuntive. Ad esempio, se è necessario accedere al database MySQL dalla ricetta stessa.

La ricetta dello chef ha la capacità di ottenere le gemme di rubino richieste per poterle utilizzare all'interno della stessa ricetta.

Usare iptable Gem nella ricetta data

Step 1 - Modifica la ricetta predefinita del ricettario e installa la gemma da utilizzare all'interno della ricetta.

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 - Carica il ricettario modificato sul server Chef.

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

Step 3 - Esecuzione del client Chef per vedere l'output.

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...

Metodo di lavoro

I passaggi di esecuzione di Chef consistono nella fase di compilazione, in cui compila tutte le risorse e in una fase di esecuzione in cui Chef esegue i provider di risorse per far convergere il nodo nello stato desiderato. Se si necessita di una particolare gemma Ruby all'interno del ricettario, è necessario installare la gemma durante la fase di complicazione.

La risorsa chef_gem farà esattamente lo stesso e in Chef Omnibus è l'unico modo per lavorare. La sua funzione principale è rendere disponibili le gemme allo Chef stesso.

Libraries in Chef fornisce un luogo per incapsulare la logica compilata in modo che le ricette del libro di cucina rimangano ordinate e pulite.

Creazione della libreria

Step 1 - Crea un metodo di supporto nella libreria del ricettario.

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

Step 2 - Usa il metodo di supporto.

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 - Carica il ricettario modificato su Chef Server.

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

Testare la libreria

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...

Metodo di lavoro

Il codice della libreria Chef può aprire la classe chef :: Recipe e aggiungere nuovi metodi come fatto nel passaggio 1. Questo passaggio non è il modo più pulito, ma il modo più semplice per farlo.

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

Migliori pratiche

Una volta aperta la classe chef :: ricetta, ci sono cambiamenti che si inquinano. Come best practice, è sempre un modo migliore per introdurre una nuova sottoclasse all'interno della libreria e definire un metodo come metodo di classe. Questo evita di estrarre lo spazio dei nomi chef :: ricetta.

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

Possiamo usare il metodo all'interno della ricetta come

IPAddress.netmask(ip)

La definizione può essere definita come un metodo logico per raggruppare le risorse, che vengono utilizzate ancora e ancora. In questo flusso, raggruppiamo le risorse e assegniamo loro un nome per recuperare la leggibilità di libri di cucina definiti.

Per fare questo, dovremmo avere una ricetta. In questo caso, stiamo usando test_cookbook e un run list di nodi, che include il ricettario.

Creazione di una definizione

Step 1 - Crea un nuovo file di definizione nella cartella delle definizioni dei libri di cucina.

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 - Usa una definizione all'interno della ricetta predefinita dei libri di cucina.

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

Step 3 - Carica il ricettario sul server dello chef.

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

Step 4 - Eseguire il client Chef sul nodo desiderato.

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]

La definizione nei libri di cucina è come i micro, che raggruppano le risorse e danno loro un nome. Una definizione ha un nome con cui si può distinguere da cui può essere chiamata all'interno della ricetta e ha un elenco di perimetri.

Nella definizione, abbiamo parametri che nel nostro codice hanno il seguente aspetto.

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

Può essere utilizzato all'interno della ricetta predefinita come segue.

capistrano_deploy_dirs do 
   deploy_to "/srv"` 
end

La variabile d'ambiente è un modo chiave per far funzionare correttamente la ricetta di Chef su un nodo particolare. Esistono diversi modi per farlo, configurandoli manualmente o utilizzando uno script Shell. L'impostazione tramite ricetta è ciò che dobbiamo eseguire qui.

Per fare questo, abbiamo bisogno di un libro di cucina qui useremmo test_cookbook e un elenco di esecuzione che contiene test_cookbook.

Impostazione della variabile d'ambiente usando la ricetta dello chef

Step 1 - Aggiorna la ricetta predefinita del ricettario con una variabile d'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 - Carica il ricettario aggiornato sul server.

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

Step 3 - Esecuzione del client Chef per creare un file temporaneo.

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...

Convalida della variabile

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

Metodo di lavoro

Ruby espone la variabile d'ambiente corrente tramite ENV –a hash per leggere e modificare la variabile d'ambiente.

Esegui risorsa

Possiamo usare la risorsa di esecuzione per fare lo stesso all'interno della ricetta predefinita dello chef del ricettario.

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- L'impostazione di una variabile d'ambiente utilizzando ENV renderà quella variabile disponibile durante l'intera esecuzione dello Chef. Al contrario, passarlo alla risorsa di esecuzione lo renderà disponibile solo per quel comando eseguito dalla risorsa.

I data bag di Chef possono essere definiti come una raccolta arbitraria di dati che è possibile utilizzare con i libri di cucina. L'uso dei data bag è molto utile quando non si desidera codificare gli attributi nelle ricette né memorizzare gli attributi nei libri di cucina.

Metodo di lavoro

Nella seguente configurazione, stiamo cercando di comunicare con l'URL dell'endpoint http. Per questo, dobbiamo creare un data bag, che conterrà i dettagli dell'URL dell'endpoint e lo utilizzerà nella nostra ricetta.

Step 1 - Crea una directory per il nostro data bag.

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

Step 2- Creare un articolo del sacchetto di dati per il cestino delle richieste. È necessario assicurarsi di utilizzare un URL requestBin definito.

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

Step 3 - Crea un data bag sul server Chef

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

Step 4 - Carica il data bag sul server Chef.

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

Step 5 - Aggiorna la ricetta predefinita del ricettario per ricevere il ricettario richiesto da un sacchetto dati.

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 - Carica il ricettario modificato sul server Chef.

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

Step 7 - Esegui il client Chef sul nodo per verificare se il bin della richiesta http viene eseguito.

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...

Come funziona

Il data bag è una raccolta denominata di voci di dati della struttura. È necessario definire l'immissione dei dati e chiamare l'elemento del bagaglio di dati nel file JSON. È anche possibile cercare un articolo del sacchetto di dati all'interno delle ricette per utilizzare i dati memorizzati nei sacchetti di dati.

Abbiamo creato un data bag chiamato hooks. Un data bag è una directory all'interno del repository Chef. Abbiamo usato il coltello per crearlo sul server.

In determinate condizioni, non è possibile mettere il server sotto il pieno controllo di Chef. In questi casi, potrebbe essere necessario accedere ai valori nei data bag di Chef dagli script. Per fare ciò, è necessario memorizzare i valori del data bag in un file JSON e consentire allo script aggiunto di accedere a tali valori.

Per questo, è necessario avere un libro di cucina. Nel nostro caso useremmo test_cookbook come prima e dovremmo avere l'elenco di esecuzione del nodo inclusa la definizione di test_cookbook in esso.

Metodo di lavoro

Step 1 - Crea un data bag.

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

Step 2 - Crea un articolo nella borsa dati.

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

Step 3 - Aggiorna l'elemento della borsa dati.

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

Utilizzo in Cookbook

Step 1 - È necessario creare un file JSON contenente i valori del sacchetto di dati utilizzando il ricettario sopra in modo che gli script esterni possano accedere a tali valori.

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 - Carica test_cookbook sul server Chef.

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

Step 3 - Esegui il client Chef sul nodo.

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 - Convalida del contenuto del file JSON generato.

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

Flusso di lavoro degli script

Nel comando precedente, la risorsa file che abbiamo utilizzato che crea il file JSON all'interno del file /etcdirectory è definita nel ricettario predefinito. Ottiene il contenuto del file direttamente dal data bag utilizzando il metodo data_bag_item. Accediamo ai valori host dall'elemento del data bag e lo convertiamo in JSON. La risorsa file utilizza i valori convertiti in JSON come contenuto e lo scrive sul disco.

I libri di cucina multipiattaforma sono quei libri di cucina che adottano un ambiente sottostante su cui verrà eseguito. Chef fornisce una serie di funzionalità, che aiutano a scrivere libri di cucina multipiattaforma in grado di funzionare su qualsiasi sistema operativo, su cui verrà distribuito. Questo aiuta uno sviluppatore a scrivere un libro di cucina completamente operativo.

Per fare questo, abbiamo bisogno di un libro di cucina. Nel nostro caso sarà test_cookbook e una run list che conterrà la definizione del libro di cucina.

Metodo di lavoro

Il recupero dei dettagli della piattaforma dei nodi e l'esecuzione della logica condizionale nel nostro ricettario dipende dalla piattaforma. Nel nostro caso, lo testeremo per Ubuntu.

Step 1 - Registra un messaggio se il nodo è Ubuntu.

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

Step 2 - Carica il ricettario sul server Chef.

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

Step 3 - Esegui il client Chef sul nodo.

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

In alternativa, se non si è interessati a una piattaforma specifica ma si ha solo bisogno di sapere quale dichiarativa si sta utilizzando, è possibile utilizzare la seguente dichiarazione.

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

Il caricamento del libro di cucina modificato e l'esecuzione del client Chef sul nodo Ubuntu mostrerà il seguente risultato.

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

Flusso di lavoro degli script

Nel comando precedente, Ohai scoprirà lo stato corrente del sistema operativo del nodo e lo memorizzerà come attributo della piattaforma con l'oggetto nodo.

node['platform']

Oppure puoi usare la sintassi dello stile del metodo:

node.platform

Impostazione dei valori specifici della piattaforma

Per impostare valori specifici della piattaforma, chef offre metodi di convenienza value_for_platform e value_for_platform_family. Possono essere utilizzati per evitare un'istruzione case complessa e utilizzare invece un semplice hash.

Ricettario di esempio

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

Nell'esempio precedente, il comando è specifico del sistema operativo come definito.

• Per Debian, "runsvdir-start" funzionerà
• Per Ubuntu, "start runsvdir" funzionerà
• Per Gentoo, "/etc/init.d/runit-start" funzionerà

La risorsa Chef rappresenta una parte del sistema operativo allo stato desiderato. È una dichiarazione di politica di configurazione che descrive lo stato desiderato di un nodo a cui si desidera portare la configurazione corrente utilizzando i fornitori di risorse. Aiuta a conoscere lo stato corrente della macchina di destinazione utilizzando il meccanismo Ohai di Chef. Aiuta anche a definire i passaggi necessari per eseguire per portare la macchina di destinazione a quello stato. Le risorse sono raggruppate in ricette che descrivono la configurazione di lavoro.

Nel caso di Chef, chef :: Platform mappa i provider e le versioni della piattaforma di ogni nodo. All'inizio di ogni esecuzione Chef-client, il server Chef raccoglie i dettagli dello stato corrente di qualsiasi macchina. Successivamente, il server Chef utilizza questi valori per identificare il provider corretto.

Sintassi delle risorse

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

Nella sintassi precedente, "tipo" è il tipo di risorsa e "nome" è il nome che useremo. Nel blocco "do" e "end" abbiamo l'attributo di quella risorsa e l'azione che dobbiamo intraprendere per quella particolare risorsa.

Ogni risorsa che utilizziamo nella ricetta ha il proprio set di azioni, che è definito all'interno dei blocchi "do" e "end".

Esempio

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

Tutte le risorse condividono un insieme comune di funzionalità, azioni, proprietà, esecuzione condizionale, notifica e percorso di azione pertinente.

Azioni	Il :nothing l'azione può essere utilizzata con qualsiasi risorsa o risorsa personalizzata.
Proprietà	Le proprietà ignore_failure, provider, retries, retry_delay e supports possono essere utilizzate con qualsiasi risorsa o risorse personalizzate.
Guardie ✔	Le esecuzioni condizionali not_if e only_if possono essere utilizzate per aggiungere protezioni aggiuntive attorno a determinate risorse, in modo che vengano eseguite solo quando la condizione è soddisfatta.
Interpreti di guardia	Valuta un comando stringa utilizzando un file script-risorsa basata: bash, csh, perl, powershell_script, python, o ruby.
Notifiche	Le notifiche di notifica e di sottoscrizione possono essere utilizzate con qualsiasi risorsa.
Percorsi relativi	Il percorso relativo # {ENV ['HOME']} può essere utilizzato con qualsiasi risorsa.
Protezione file di Windows	Il template, file, remote_file, cookbook_file, directory, e remote_directory le risorse supportano l'uso dell'ereditarietà e degli elenchi di controllo di accesso (ACL) all'interno delle ricette.
Esegui in fase di compilazione	A volte una risorsa deve essere eseguita prima di ogni altra risorsa o dopo che tutte le risorse sono state aggiunte alla raccolta di risorse.

Risorse disponibili

apt_package

Utilizzare il apt_package risorsa per gestire i pacchetti per le piattaforme Debian e Ubuntu.

Bash

Utilizzare il bashrisorsa per eseguire script utilizzando l'interprete Bash. Questa risorsa può anche utilizzare una qualsiasi delle azioni e proprietà disponibili perexecuterisorsa. I comandi eseguiti con questa risorsa non sono (per loro natura) idempotenti, in quanto sono tipicamente unici per l'ambiente in cui vengono eseguiti. Usa not_if e only_if per proteggere questa risorsa dall'idempotenza.

Lotto

Utilizzare il batchrisorsa per eseguire uno script batch utilizzando l'interprete cmd.exe. Ilbatch resource crea ed esegue un file temporaneo (simile a come il file script risorsa si comporta), piuttosto che eseguire il comando inline.

Questa risorsa eredita le azioni (: run e: nothing) e le proprietà (crea, cwd, ambiente, gruppo, percorso, timeout e utente) dal executerisorsa. I comandi eseguiti con questa risorsa non sono (per loro natura) idempotenti, in quanto sono tipicamente unici per l'ambiente in cui vengono eseguiti. Usonot_if e only_if per proteggere questa risorsa dall'idempotenza.

bff_package

Utilizzare il bff_package risorsa per gestire i pacchetti per la piattaforma AIX utilizzando il installputilità. Quando un pacchetto viene installato da un file locale, deve essere aggiunto al nodo utilizzando l'estensioneremote_file o cookbook_file resources.

chef_gem

Utilizzare il chef_gemrisorsa per installare una gemma solo per l'istanza di Ruby dedicata allo Chef-Client. Quando un gem viene installato da un file locale, deve essere aggiunto al nodo utilizzando l'estensioneremote_file o cookbook_file risorse.

Il chef_gem la risorsa funziona con tutte le stesse proprietà e opzioni di gem_packageresource, ma non accetta la proprietà gem_binary perché utilizza sempre CurrentGemEnvironment in cui è in esecuzione Chef-Client. Oltre a eseguire azioni simili agem_package risorsa, il chef_gem risorsa fa quanto sopra.

ricettario_file

Utilizzare il cookbook_file risorsa per trasferire i file da una sottodirectory di COOKBOOK_NAME / files / a un percorso specificato situato su un host che esegue ChefClient.

Il file viene selezionato in base alla specificità del file, che consente di utilizzare diversi file di origine in base al nome host, alla piattaforma host (sistema operativo, distribuzione o, a seconda dei casi) o alla versione della piattaforma. I file che si trovano nella sottodirectory COOKBOOK_NAME / files / default possono essere utilizzati su qualsiasi piattaforma.

Cron

Utilizzare la risorsa cron per gestire le voci cron per la pianificazione dei lavori basata sul tempo. Le proprietà per una pianificazione verranno impostate su * se non fornite. La risorsa cron richiede l'accesso a un programma crontab, in genere cron.

Csh

Usa la risorsa csh per eseguire gli script usando l'interprete csh. Questa risorsa può anche utilizzare una qualsiasi delle azioni e proprietà disponibili per la risorsa di esecuzione.

I comandi eseguiti con questa risorsa non sono (per loro natura) idempotenti, in quanto sono tipicamente unici per l'ambiente in cui vengono eseguiti. Usa not_if e only_if per proteggere questa risorsa dall'idempotenza.

Distribuisci

Utilizzare il deployrisorsa per gestire e controllare le distribuzioni. Questa è una risorsa popolare, ma è anche complessa, con il maggior numero di proprietà, più provider, la complessità aggiuntiva dei callback, oltre a quattro attributi che supportano le modifiche del layout dall'interno di una ricetta.

Directory

Utilizzare il directoryrisorsa per gestire una directory, che è una gerarchia di cartelle che comprende tutte le informazioni memorizzate su un computer. La directory root è il livello superiore, in cui è organizzato il resto della directory.

Il directoryresource utilizza la proprietà name per specificare il percorso di una posizione in una directory. In genere, è richiesta l'autorizzazione per accedere a tale posizione nella directory.

dpkg_package

Utilizzare il dpkg_package risorsa per gestire i pacchetti per dpkgpiattaforma. Quando un pacchetto viene installato da un file locale, deve essere aggiunto al nodo utilizzando l'estensioneremote_file o cookbook_file risorse.

easy_install_package

Utilizzare il easy_install_package risorsa per gestire i pacchetti per la piattaforma Python.

Env

Utilizzare il envrisorsa per gestire le chiavi di ambiente in Microsoft Windows. Dopo aver impostato una chiave di ambiente, è necessario riavviare Microsoft Windows prima che la chiave di ambiente sia disponibile per l'Utilità di pianificazione.

erl_call

Utilizzare il erl_callrisorsa per connettersi a un nodo situato all'interno di un sistema Erlang distribuito. I comandi eseguiti con questa risorsa non sono (per loro natura) idempotenti, in quanto sono tipicamente unici per l'ambiente in cui vengono eseguiti. Usa not_if e only_if per proteggere questa risorsa dall'idempotenza.

Eseguire

Utilizzare il executerisorsa per eseguire un singolo comando. I comandi eseguiti con questa risorsa non sono (per loro natura) idempotenti, in quanto sono tipicamente unici per l'ambiente in cui vengono eseguiti. Usonot_if e only_if per proteggere questa risorsa dall'idempotenza.

File

Utilizzare il file risorsa per gestire i file direttamente su un nodo.

freebsd_package

Utilizzare il freebsd_package risorsa per gestire i pacchetti per la piattaforma FreeBSD.

gem_package

Utilizzare il gem_packagerisorsa per gestire i pacchetti di gemme che sono inclusi solo nelle ricette. Quando un pacchetto viene installato da un file locale, deve essere aggiunto al nodo utilizzando l'estensioneremote_file o cookbook_file risorse.

Idiota

Utilizzare il gitrisorsa per gestire le risorse di controllo del codice sorgente esistenti in un repository git. git versione 1.6.5 (o successiva) è necessaria per utilizzare tutte le funzionalità nella risorsa git.

Gruppo

Utilizzare il group risorsa per gestire un gruppo locale.

homebrew_package

Utilizzare il homebrew_package risorsa per gestire i pacchetti per la piattaforma Mac OS X.

http_request

Utilizzare il http_requestrisorsa per inviare una richiesta HTTP (GET, PUT, POST, DELETE, HEAD o OPTIONS) con un messaggio arbitrario. Questa risorsa è spesso utile quando sono necessari callback personalizzati.

Ifconfig

Utilizzare il ifconfig risorsa per gestire le interfacce.

ips_package

Utilizzare il ips_package risorsa per gestire i pacchetti (utilizzando Image Packaging System (IPS)) sulla piattaforma Solaris 11.

Ksh

Utilizzare il kshrisorsa per eseguire gli script utilizzando l'interprete della shell Korn (ksh). Questa risorsa può anche utilizzare una qualsiasi delle azioni e proprietà disponibili per la risorsa di esecuzione.

I comandi eseguiti con questa risorsa non sono (per loro natura) idempotenti, in quanto sono tipicamente unici per l'ambiente in cui vengono eseguiti. Usa not_if e only_if per proteggere questa risorsa dall'idempotenza.

Link

Utilizzare il link risorsa per creare collegamenti simbolici o fisici.

Log

Utilizzare il logrisorsa per creare voci di registro. La risorsa di log si comporta come qualsiasi altra risorsa: incorporata nella raccolta di risorse durante la fase di compilazione e quindi eseguita durante la fase di esecuzione. (Per creare una voce di registro che non è incorporata nella raccolta di risorse, utilizzare Chef :: Log invece della risorsa di registro)

macports_package

Usa la risorsa macports_package per gestire i pacchetti per la piattaforma Mac OS X.

Mdadm

Utilizzare il mdadmrisorsa per gestire i dispositivi RAID in un ambiente Linux utilizzando l'utility mdadm. Il provider mdadm creerà e assemblerà un array, ma non creerà il file di configurazione utilizzato per rendere persistente l'array al riavvio.

Se è richiesto il file di configurazione, è necessario specificarlo specificando un modello con il layout di array corretto, quindi utilizzando il provider di montaggio per creare una voce di tabella dei file system (fstab).

Montare

Utilizzare la risorsa di montaggio per gestire un file system montato.

Ohai

Utilizzare il ohairisorsa per ricaricare la configurazione Ohai su un nodo. Ciò consente alle ricette che modificano gli attributi di sistema (come una ricetta che aggiunge un utente) di fare riferimento a quegli attributi in un secondo momento durante l'esecuzione chef-client.

Pacchetto

Utilizzare il packagerisorsa per gestire i pacchetti. Quando il pacchetto viene installato da un file locale (come con RubyGems, dpkg o RPM Package Manager), il file deve essere aggiunto al nodo utilizzando le risorse remote_file o cookbook_file.

pacman_package

Utilizzare il pacman_package risorsa per gestire i pacchetti (utilizzando pacman) sulla piattaforma Arch Linux.

powershell_script

Utilizzare il powershell_scriptrisorsa per eseguire uno script utilizzando l'interprete di Windows PowerShell, in modo molto simile a come vengono utilizzati lo script e le risorse basate su script (bash, csh, perl, python e ruby). Il powershell_script è specifico per la piattaforma Microsoft Windows e l'interprete di Windows PowerShell.

Pitone

Utilizzare il pythonrisorsa per eseguire script utilizzando l'interprete Python. Questa risorsa può anche utilizzare una qualsiasi delle azioni e proprietà disponibili per la risorsa di esecuzione.

I comandi eseguiti con questa risorsa non sono (per loro natura) idempotenti, in quanto sono tipicamente unici per l'ambiente in cui vengono eseguiti. Usa not_if e only_if per proteggere questa risorsa dall'idempotenza.

Riavvia

Utilizzare il rebootrisorsa per riavviare un nodo, passaggio necessario con alcune installazioni su determinate piattaforme. Questa risorsa è supportata per l'uso sulle piattaforme Microsoft Windows, Mac OS X e Linux.

chiave_registro

Utilizzare il registry_key risorsa per creare ed eliminare le chiavi di registro in Microsoft Windows.

directory_remota

Utilizzare il remote_directoryrisorsa per trasferire in modo incrementale una directory da un ricettario a un nodo. La directory che viene copiata dal ricettario dovrebbe trovarsi sotto COOKBOOK_NAME / files / default / REMOTE_DIRECTORY.

La risorsa remote_directory obbedirà alla specificità del file.

remote_file

Utilizzare il remote_filerisorsa per trasferire un file da una posizione remota utilizzando la specificità del file. Questa risorsa è simile alla risorsa file.

Itinerario

Utilizza la risorsa route per gestire la tabella di routing del sistema in un ambiente Linux.

rpm_package

Utilizzare il rpm_package risorsa per gestire i pacchetti per la piattaforma RPM Package Manager.

Rubino

Utilizzare il rubyrisorsa per eseguire script utilizzando l'interprete Ruby. Questa risorsa può anche utilizzare una qualsiasi delle azioni e proprietà disponibili per la risorsa di esecuzione.

I comandi eseguiti con questa risorsa non sono (per loro natura) idempotenti, in quanto sono tipicamente unici per l'ambiente in cui vengono eseguiti. Usa not_if e only_if per proteggere questa risorsa dall'idempotenza.

ruby_block

Utilizzare il ruby_blockrisorsa per eseguire il codice Ruby durante un'esecuzione Chef-Client. Il codice Ruby nella risorsa ruby_block viene valutato con altre risorse durante la convergenza, mentre il codice Ruby all'esterno di una risorsa ruby_block viene valutato prima delle altre risorse, mentre la ricetta viene compilata.

Script

Utilizza la risorsa script per eseguire gli script utilizzando un interprete specificato, come Bash, csh, Perl, Python o Ruby. Questa risorsa può anche utilizzare una qualsiasi delle azioni e proprietà disponibili per la risorsa di esecuzione.

I comandi eseguiti con questa risorsa non sono (per loro natura) idempotenti, in quanto sono tipicamente unici per l'ambiente in cui vengono eseguiti. Usa not_if e only_if per proteggere questa risorsa dall'idempotenza.

Servizio

Utilizzare il service risorsa per gestire un servizio.

smart_os_package

Utilizzare il smartos_package risorsa per gestire i pacchetti per la piattaforma SmartOS.

solaris_package

Il solaris_package risorsa viene utilizzata per gestire i pacchetti per la piattaforma Solaris.

Sovversione

Utilizzare il subversion risorsa per gestire le risorse di controllo del codice sorgente esistenti in un repository Subversion.

Modello

Utilizzare il templaterisorsa per gestire il contenuto di un file utilizzando un modello Embedded Ruby (ERB) trasferendo i file da una sottodirectory di COOKBOOK_NAME / templates / a un percorso specificato situato su un host che esegue Chef-Client. Questa risorsa include azioni e proprietà dalla risorsa file. I file modello gestiti dalla risorsa modello seguono le stesse regole di specificità file delle risorse file_remoto e file.

Utente

Utilizzare il user risorsa per aggiungere utenti, aggiornare utenti esistenti, rimuovere utenti e per bloccare / sbloccare le password degli utenti.

windows_package

Utilizzare il windows_package risorsa per gestire i pacchetti Microsoft Installer Package (MSI) per la piattaforma Microsoft Windows.

windows_service

Utilizzare il windows_service risorsa per gestire un servizio sulla piattaforma Microsoft Windows.

yum_package

Utilizzare il yum_packagerisorsa per installare, aggiornare e rimuovere pacchetti con Yum per le piattaforme Red Hat e CentOS. La risorsa yum_package è in grado di risolvere fornisce dati per pacchetti in modo molto simile a Yum quando viene eseguito dalla riga di comando. Ciò consente una varietà di opzioni per l'installazione di pacchetti, come versioni minime, offerte virtuali e nomi di libreria.

Lightweight resource provider (LWRP) fornisce un'opzione per estendere l'elenco delle risorse disponibili estendendone le funzionalità e consente all'utente di Chef di creare risorse personalizzate.

Creando risorse personalizzate si possono semplicemente scrivere libri di cucina perché si possono possedere risorse personalizzate arricchite utilizzando Chef DSL che aiuta a rendere il codice della ricetta più espressivo.

Nella comunità di Chef, molte delle risorse personalizzate vengono implementate utilizzando LWRP. Ci sono molti esempi funzionanti di LWRP comeiptables_rules e apt_repository.

Metodo di lavoro

Assicurati che uno abbia il nome del ricettario Testing_resource e un run_list del nodo che contenga Testing_resource ricettario.

Costruire LWRP

Step 1 - Crea una risorsa personalizzata nel ricettario 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 - Crea un provider per le risorse nel ricettario 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 - Usa una nuova risorsa modificando la ricetta predefinita di Testing_resource.

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

Step 4 - Carica il ricettario modificato sul server Chef.

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

Step 5 - Esegui Chef-Client sul nodo.

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 - Convalida il contenuto del file generato.

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

Script del flusso di lavoro

I LWRP vivono nei libri di cucina. Una risorsa personalizzata risiede all'interno dei ricettari e sarà disponibile sotto il nome del ricettario. Nel flusso di lavoro, prima definiamo le definizioni e poi passiamo gli attributi alle risorse che verranno utilizzate nel ricettario. Infine, usiamo quelle azioni e attributi nella nostra ricetta.

In Chef, i progetti sono gli strumenti per scoprire e registrare esattamente ciò che è presente sul server. I progetti registrano tutte le cose richieste come direttori, pacchetti, file di configurazione e così via. I progetti hanno la capacità di dividere le informazioni del server in vari formati. Uno di questi è la ricetta dello chef. Questo aiuta a configurare un server unico utilizzando Chef.

Metodo di adorazione

Dobbiamo avere Python e Git installati sul nodo in cui dobbiamo eseguire il progetto.

Step 1 - Installa il progetto.

vipin@server:~$ pip install blueprint

Step 2 - Crea un progetto.

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 - Crea un libro di cucina dal progetto.

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

Step 4 - Convalida il contenuto del file generato.

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 del flusso di lavoro

Blueprint è un pacchetto Python che trova tutti i dati di configurazione rilevanti del server e li memorizza in un repository Git. Ogni progetto ha il proprio nome.

Si può chiedere al progetto di mostrare il contenuto del suo repository Git in varie formanti.

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

Comandi di visualizzazione dei progetti

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

Il comando precedente mostra tutti i tipi di pacchetti installati. Altri comandi di visualizzazione sono i seguenti:

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

In Chef, la creazione di file di configurazione e lo spostamento di pacchetti sono i componenti chiave. Ci sono diversi modi in cui Chef gestisce lo stesso. Esistono diversi modi in cui Chef supporta nella gestione dei file e dei pacchetti software.

Installazione di pacchetti da repository di terze parti

Step 1 - Modifica la ricetta predefinita del ricettario.

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 - Modifica i metadati per aggiungere dipendenza dal ricettario di apt.

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

Step 3 - Carica il ricettario modificato sul server Chef.

Step 4 - Verifica che il pacchetto che stai tentando di installare non sia ancora installato.

Step 5 - Convalida il repository predefinito.

Step 6 - Esegui Chef-Client sul nodo.

Step 7 - Convalida che il pacchetto richiesto sia installato.

Installazione del software dall'origine

Se è necessario installare un software che non è disponibile come pacchetto per una data piattaforma, è necessario compilarlo da soli. In Chef, possiamo farlo utilizzando la risorsa script.

Step 1 - Modifica la ricetta predefinita.

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 - Carica il ricettario modificato sul server Chef.

Step 3 - Esegui lo Chef-Client sul nodo.

Step 4 - Verifica che nginx sia installato.

I libri di cucina della comunità sono simili a qualsiasi altro libro di cucina. L'unico motivo per cui si chiama libro di cucina della comunità è perché chiunque sappia scrivere libri di cucina può unirsi a questa comunità e caricare i propri libri di cucina nell'hub centralizzato. Questi libri di cucina sono disponibili gratuitamente e chiunque può scaricarli e utilizzarli. Per poter utilizzare questi libri di cucina della comunità, è necessario scaricarli, modificarli secondo il requisito e caricarli sul rispettivo server Chef.

È necessario che il coltello sia configurato sul proprio sistema per aggiornare, caricare e scaricare i libri di cucina. Interagisci con i libri di cucina utilizzando i comandi del ricettario del coltello. Con il ricettario del coltello, puoi creare, eliminare, mostrare, elencare, scaricare e caricare libri di cucina. Leggere la documentazione dei comandi del ricettario del coltello per ulteriori informazioni nel Capitolo 7.

Di seguito è riportato il collegamento dei libri di cucina della comunità: https://supermarket.chef.io/cookbooksdirectory