Chef - Kurzanleitung

Chef ist eine Open-Source-Technologie, die von Opscode entwickelt wurde. Adam Jacob, Mitbegründer von Opscode, ist als Gründer von Chef bekannt. Diese Technologie verwendet die Ruby-Codierung, um grundlegende Bausteine ​​wie Rezepte und Kochbücher zu entwickeln. Chef wird in der Infrastrukturautomatisierung eingesetzt und hilft bei der Reduzierung manueller und sich wiederholender Aufgaben für das Infrastrukturmanagement.

Chef hat eine eigene Konvention für verschiedene Bausteine, die für die Verwaltung und Automatisierung der Infrastruktur erforderlich sind.

Warum Chef?

Chef ist eine Konfigurationsmanagement-Technologie zur Automatisierung der Infrastrukturbereitstellung. Es wurde auf Basis der Ruby DSL-Sprache entwickelt. Es wird verwendet, um die Konfiguration und Verwaltung des Servers des Unternehmens zu optimieren. Es kann in jede Cloud-Technologie integriert werden.

In DevOps verwenden wir Chef, um Server und Anwendungen intern und in der Cloud bereitzustellen und zu verwalten.

Merkmale des Küchenchefs

Im Folgenden sind die wichtigsten Merkmale des Küchenchefs aufgeführt:

• Chef verwendet die beliebte Ruby-Sprache, um eine domänenspezifische Sprache zu erstellen.

• Chef macht keine Annahmen über den aktuellen Status eines Knotens. Es verwendet seine Mechanismen, um den aktuellen Status der Maschine abzurufen.

• Chef ist ideal für die Bereitstellung und Verwaltung von Cloud-Server, Speicher und Software.

Vorteile des Küchenchefs

Chef bietet die folgenden Vorteile -

• Lower barrier for entry - Da Chefkoch für die Konfiguration die Ruby-Muttersprache verwendet, eine Standardkonfigurationssprache, kann sie von jedem mit etwas Entwicklungserfahrung leicht erlernt werden.

• Excellent integration with cloud- Mit dem Messer-Dienstprogramm kann es problemlos in jede Cloud-Technologie integriert werden. Es ist das beste Tool für ein Unternehmen, das seine Infrastruktur in einer Multi-Cloud-Umgebung verteilen möchte.

Nachteile des Küchenchefs

Einige der Hauptnachteile von Chef sind folgende:

• Einer der großen Nachteile von Chef ist die Art und Weise, wie Kochbücher gesteuert werden. Es muss ständig gebabelt werden, damit die Leute, die arbeiten, nicht mit anderen Kochbüchern durcheinander kommen.

• Es ist nur Chef Solo verfügbar.

• In der aktuellen Situation passt es nur gut zur AWS Cloud.

• Es ist nicht leicht zu lernen, wenn die Person nicht mit Ruby vertraut ist.

• Die Dokumentation fehlt noch.

Schlüsselbausteine ​​des Küchenchefs

Rezept

Es kann als eine Sammlung von Attributen definiert werden, die zum Verwalten der Infrastruktur verwendet werden. Diese im Rezept enthaltenen Attribute werden verwendet, um den vorhandenen Status zu ändern oder einen bestimmten Infrastrukturknoten festzulegen. Sie werden während der Ausführung des Chef-Clients geladen und mit dem vorhandenen Attribut des Knotens (Computers) verglichen. Es gelangt dann zu dem Status, der in der Knotenressource des Rezepts definiert ist. Es ist das Hauptarbeitspferd des Kochbuchs.

Kochbuch

Ein Kochbuch ist eine Sammlung von Rezepten. Sie sind die Grundbausteine, die auf den Chef-Server hochgeladen werden. Wenn ein Chef-Lauf stattfindet, wird sichergestellt, dass die darin enthaltenen Rezepte eine bestimmte Infrastruktur in den gewünschten Zustand bringen, wie im Rezept aufgeführt.

Ressource

Es ist die Grundkomponente eines Rezepts, mit dem die Infrastruktur mit verschiedenen Zuständen verwaltet wird. Ein Rezept kann mehrere Ressourcen enthalten, die bei der Konfiguration und Verwaltung der Infrastruktur hilfreich sind. Zum Beispiel -

• package - Verwaltet die Pakete auf einem Knoten

• service - Verwaltet die Dienste auf einem Knoten

• user - Verwaltet die Benutzer auf dem Knoten

• group - Verwaltet Gruppen

• template - Verwaltet die Dateien mit der eingebetteten Ruby-Vorlage

• cookbook_file - Überträgt die Dateien aus dem Unterverzeichnis files im Kochbuch an einen Speicherort auf dem Knoten

• file - Verwaltet den Inhalt einer Datei auf dem Knoten

• directory - Verwaltet die Verzeichnisse auf dem Knoten

• execute - Führt einen Befehl auf dem Knoten aus

• cron - Bearbeitet eine vorhandene Cron-Datei auf dem Knoten

Attribut

Sie sind im Grunde Einstellungen. Sie können als Schlüsselwertpaar von allem angesehen werden, was man im Kochbuch verwenden möchte. Es gibt verschiedene Arten von Attributen, die angewendet werden können, wobei die endgültigen Einstellungen, unter denen der Knoten arbeitet, unterschiedliche Vorrang haben.

Datei

Es ist ein Unterverzeichnis innerhalb des Kochbuchs, das alle statischen Dateien enthält, die auf den Knoten abgelegt werden, die die Kochbücher verwenden. Ein Rezept kann dann als Ressource deklariert werden, die die Dateien aus diesem Verzeichnis auf den endgültigen Knoten verschiebt.

Vorlagen

Sie ähneln Dateien, sind jedoch nicht statisch. Vorlagendateien enden mit der Erweiterung .ebr, dh sie enthalten eingebettetes Ruby. Sie werden hauptsächlich verwendet, um einen Attributwert in die Dateien einzufügen, um die endgültige Dateiversion zu erstellen, die auf dem Knoten platziert wird.

Metadata.rb

Es wird verwendet, um die Metadaten zum Paket zu verwalten. Dies beinhaltet Details wie den Namen und Details des Pakets. Es enthält auch Dinge wie Abhängigkeitsinformationen, die angeben, welche Kochbücher dieses Kochbuch zum Betrieb benötigt. Auf diese Weise kann der Chef-Server die Ausführungsliste des Knotens korrekt erstellen und sicherstellen, dass alle Teile korrekt übertragen werden.

Standard-Kochbuchstruktur

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 - Verwandte Technologien

Im Folgenden finden Sie eine Liste der Technologien, die mit dem Küchenchef in Verbindung stehen.

Marionette

Puppet bietet eine Standardmethode für die Bereitstellung und Bedienung von Software, unabhängig davon, wo sie ausgeführt wird. Es ist eine automatisierte Verwaltungs-Engine für Linux-, Unix- und Windows-Systeme, die Verwaltungsaufgaben basierend auf zentralisierten Spezifikationen ausführt.

Die primäre features of Puppet sind wie folgt -

• Implementierung neuer Systeme mit einheitlicher Konfiguration.
• Aktualisieren der Systeme und Aktualisieren der Sicherheits- und Softwarepakete.
• Integration neuer Funktionen und Hinzufügen geschickter Funktionen.
• Anpassen von Konfigurationen zur Sicherstellung der Verfügbarkeit von Datenquellen.
• Optimierung der verfügbaren Ressourcen und Minimierung der Kosten.
• Vereinfachung der Rollen und Ermöglichung, dass sich das Team auf zentrale und produktive Themen konzentriert.
• Die verfügbare Infrastruktur aus der Vogelperspektive betrachten.

Ansible

Ansible ist eine radikal einfache IT-Automatisierungsplattform, die die Bereitstellung Ihrer Anwendungen und Systeme erleichtert. Vermeiden Sie das Schreiben von Skripten oder benutzerdefiniertem Code zum Bereitstellen und Aktualisieren Ihrer Anwendungen - automatisieren Sie in einer Sprache, die sich mit SSH dem einfachen Englisch nähert, ohne dass Agenten auf Remote-Systemen installiert werden müssen.

Die primäre features of Ansible sind wie folgt -

• Einfach und leicht zu lernen
• Geschrieben in Python
• Agentless
• YAML-basierte Playbooks
• Ansible Galaxie

SaltStack

SaltStack wird für die datengesteuerte Konfiguration verwendet. Es ist ein neuer Ansatz des Infrastrukturmanagements, der auf einem dynamischen Kommunikationsbus basiert. Es wird für die datengesteuerte Orchestrierung, die Remote-Ausführung für jede Infrastruktur und das Konfigurationsmanagement für jeden App-Stack verwendet.

Stoff

Fabric ist eine Python-basierte Programmiersprache, die als Python-API entwickelt wurde und in Python-Code importiert werden muss, um eine Infrastruktur zu konfigurieren und zu verwalten.

Chef arbeitet an einem dreistufigen Client-Server-Modell, bei dem die Arbeitseinheiten wie Kochbücher auf der Chef-Workstation entwickelt werden. Über die Befehlszeilenprogramme wie Messer werden sie auf den Chef-Server hochgeladen, und alle in der Architektur vorhandenen Knoten werden beim Chef-Server registriert.

Um die funktionierende Chef-Infrastruktur einzurichten, müssen mehrere Dinge nacheinander eingerichtet werden.

Im obigen Setup haben wir die folgenden Komponenten.

Chef Workstation

Dies ist der Ort, an dem alle Konfigurationen entwickelt werden. Die Chef-Workstation ist auf dem lokalen Computer installiert. Eine detaillierte Konfigurationsstruktur wird in den späteren Kapiteln dieses Tutorials erläutert.

Chef Server

Dies funktioniert als zentrale Arbeitseinheit des Chef-Setups, in der alle Konfigurationsdateien nach der Entwicklung hochgeladen werden. Es gibt verschiedene Arten von Chef-Servern, einige sind gehostete Chef-Server, andere sind integrierte Voraussetzungen.

Chef Nodes

Dies sind die eigentlichen Maschinen, die vom Chef-Server verwaltet werden. Alle Knoten können je nach Anforderung unterschiedlich eingerichtet werden. Der Chef-Client ist die Schlüsselkomponente aller Knoten, die beim Einrichten der Kommunikation zwischen dem Chef-Server und dem Chef-Knoten hilfreich ist. Die anderen Komponenten des Chef-Knotens sind Ohai, mit deren Hilfe der aktuelle Status eines Knotens zu einem bestimmten Zeitpunkt ermittelt werden kann.

Die Verwendung des Versionskontrollsystems ist ein wesentlicher Bestandteil der Infrastrukturautomatisierung. Es gibt verschiedene Arten von Versionskontrollsystemen wie SVN, CVS und GIT. Aufgrund der Beliebtheit von GIT in der Chef-Community werden wir das GIT-Setup verwenden.

Note - Stellen Sie sich eine Infrastruktur nicht als Code ohne Versionskontrollsystem vor.

Unter Windows

Step 1- Laden Sie das Windows-Installationsprogramm von www.git-scm.org herunter und befolgen Sie die Installationsschritte.

Step 2 - Melden Sie sich für ein zentrales Repository auf GitHub an.

Step 3- Laden Sie den SSH-Schlüssel in das GitHub-Konto hoch, damit Sie problemlos damit interagieren können. Weitere Informationen zum SSH-Schlüssel finden Sie unter folgendem Linkhttps://help.github.com/articles/generatingssh-keys.

Step 4 - Erstellen Sie schließlich ein Repo auf dem Github-Konto, indem Sie besuchen https://github.com/new mit dem Namen Chef-Repo.

Bevor Sie tatsächlich mit dem Schreiben eines Kochbuchs beginnen, können Sie ein erstes GIT-Repository auf der Entwicklungsbox einrichten und das von Opscode bereitgestellte leere Repository klonen.

Step 1 - Laden Sie die leere Struktur des Opscode Chef-Repositorys herunter.

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

Step 2 - Extrahieren Sie die Teerkugel.

$ tar –xvf master

Step 3 - Benennen Sie das Verzeichnis um.

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

Step 4 - Ändern Sie das aktuelle Arbeitsverzeichnis in Chef Repo.

$ cd chef-repo

Step 5 - Initialisieren Sie ein neues Get Repo.

$ git init.

Step 6 - Verbinde dich mit deinem Repo am Git Hub.

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

Step 7 - Schieben Sie das lokale Repo auf Github.

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

Wenn Sie das oben beschriebene Verfahren anwenden, erhalten Sie ein leeres Koch-Repo. Sie können dann mit der Entwicklung der Rezepte und Kochbücher beginnen. Sobald Sie fertig sind, können Sie die Änderungen auf den GitHub übertragen.

Chef folgt dem Konzept der Client-Server-Architektur. Um mit Chef arbeiten zu können, muss Chef auf der Workstation eingerichtet und die Konfiguration lokal entwickelt werden. Später kann es auf den Chef-Server hochgeladen werden, damit sie auf den Chef-Knoten funktionieren, die konfiguriert werden müssen.

Opscode bietet eine vollständig verpackte Version, für die keine externen Voraussetzungen gelten. Dieser voll verpackte Chef heißt deromnibus installer.

Auf Windows-Computer

Step 1 - Laden Sie die Setup-MSI-Datei von chefDK auf den Computer herunter.

Step 2 - Befolgen Sie die Installationsschritte und installieren Sie es am Zielspeicherort.

Das Setup sieht wie im folgenden Screenshot gezeigt aus.

ChefDK-Pfadvariable

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

Auf Linux-Maschine

Um auf dem Linux-Computer einzurichten, müssen wir zuerst Curl auf dem Computer bekommen.

Step 1 - Sobald Curl auf dem Computer installiert ist, müssen wir Chef mit dem Omnibus Chef-Installationsprogramm von Opscode auf der Workstation installieren.

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

Step 2 - Installieren Sie Ruby auf dem Computer.

Step 3 - Fügen Sie Ruby zur Pfadvariablen hinzu.

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

Der Omnibus-Chef installiert Ruby und alle erforderlichen Ruby-Edelsteine /opt/chef/embedded beim Hinzufügen /opt/chef/embedded/bin Verzeichnis in die Datei .bash_profile.

Wenn Ruby bereits installiert ist, installieren Sie das Chef Ruby-Juwel auf dem Computer, indem Sie den folgenden Befehl ausführen.

$ gem install chef

Damit der Chef-Knoten mit dem Chef-Server kommunizieren kann, müssen Sie den Chef-Client auf dem Knoten einrichten.

Chef Client

Dies ist eine der Schlüsselkomponenten des Chef-Knotens, der die Kochbücher vom Chef-Server abruft und auf dem Knoten ausführt. Es ist auch als Chef Provisioner bekannt.

Hier verwenden wir Vagrant, um die VM zu verwalten. Vagrant kann auch mit dem Provisioner wie Shell-Skript, Chef und Puppet konfiguriert werden, um die VM in den gewünschten Zustand zu versetzen. In unserem Fall verwenden wir Vagrant, um VMs mithilfe von VirtualBox und Chef Client als Provisioner zu verwalten.

Step 1 - Laden Sie VirtualBox von herunter und installieren Sie es https://www.virtualbox.org/wiki/downlod

Step 2 - Laden Sie Vagrant herunter und installieren Sie es unter http://downloads.vagrantup.com

Step 3 - Installieren Sie das Vagrant Omnibus-Plugin, damit Vagrant den Chef-Client auf der VM installieren kann.

$ vagrant plugin install vagrant-omnibus

Virtuelles Erstellen und Booten

Step 1- Wir können die erforderliche Vagrant-Box aus dem Opscode Vagrant Repo herunterladen. Laden Sie die Box opscode-ubuntu-12.04 von der folgenden URL herunterhttps://opscode-vmbento.s3.amazonaws.com/vagrant/opscode_ubuntu-12.04_provisionerless.box

Step 2 - Wenn Sie die Vagrant-Datei haben, laden Sie den Pfad herunter, den Sie zum Bearbeiten der Vagrant-Datei benötigen.

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

Im obigen Programm müssen Sie den Namen <YOUR_ORG> mit dem richtigen oder erforderlichen Organisationsnamen aktualisieren.

Step 3- Der nächste Schritt nach der Konfiguration ist das Aufstellen der Vagabundbox. Dazu müssen Sie an den Ort wechseln, an dem sich die Vagrant-Box befindet, und den folgenden Befehl ausführen.

$ vagrant up

Step 4 - Sobald der Computer hochgefahren ist, können Sie sich mit dem folgenden Befehl am Computer anmelden.

$ vagrant ssh

Im obigen Befehl wird vagrantfile in einer Ruby Domain Specific Language (DSL) zum Konfigurieren der virtuellen Vagrant-Maschine geschrieben.

In der Vagrant-Datei haben wir das Konfigurationsobjekt. Vagrant verwendet dieses Konfigurationsobjekt, um die VM zu konfigurieren.

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

Innerhalb des Konfigurationsblocks teilen Sie vagrant mit, welches VM-Image verwendet werden soll, um den Knoten zu starten.

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

Im nächsten Schritt werden Sie Vagrant anweisen, das Omnibus-Plugin herunterzuladen.

config.omnibus.chef_version = :latest

Konfigurieren Sie nach Auswahl der zu startenden VM-Box, wie die Box mit Chef bereitgestellt werden soll.

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

Darin müssen Sie Anweisungen zum Anschließen des virtuellen Knotens an den Chef-Server einrichten. Sie müssen Vagrant mitteilen, wo Sie das gesamte Chef-Material auf dem Knoten speichern müssen.

chef.provisioning_path = "/etc/chef"

Test Kitchen ist das integrierte Test-Framework von Chef. Es ermöglicht das Schreiben von Testrezepten, die auf den VMs ausgeführt werden, sobald sie mithilfe des Kochbuchs instanziiert und konvergiert wurden. Die Testrezepte werden auf dieser VM ausgeführt und können überprüfen, ob alles wie erwartet funktioniert.

ChefSpecist etwas, das nur einen Kochlauf simuliert. Testküche startet echten Knoten und führt Chef darauf aus.

Step 1 - Installieren Sie Testküche Ruby Gem und Testküche Vagrant Gem, damit die Testküche Vagrant zum Hochfahren des Tests verwenden kann.

$ gem install kitchen 
$ gem install kitchen-vagrant

Step 2- Testküche einrichten. Dies kann durch Erstellen erfolgen.kitchen.yml im Kochbuchverzeichnis.

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

Im obigen Code definiert ein Teil, dass Vagrant die VMs hochfahren muss, und definiert, dass Omnibus Chef auf dem Zielknoten installieren soll.

Der zweite Teil definiert, auf welcher Plattform Sie die Kochbücher testen möchten. Vagrant erstellt und zerstört immer neue Instanzen. Sie müssen sich nicht vor den Nebenwirkungen von Vagrant-VMs fürchten, die Sie mithilfe der Vagrant-Datei starten.

Die Testküche kann als temporäre Umgebung betrachtet werden, mit deren Hilfe Kochbücher in einer temporären Umgebung ausgeführt und getestet werden können, die der Produktion ähnelt. Wenn die Testküche aktiviert ist, kann sichergestellt werden, dass der angegebene Code funktioniert, bevor er tatsächlich für Test-, Vorproduktions- und Produktionsumgebungen bereitgestellt wird. Diese Funktion der Testküche wird von vielen Organisationen als Set befolgt, bevor die Kochbücher in eine tatsächliche Arbeitsumgebung gestellt werden.

Testen Sie den Workflow in der Küche

Im Folgenden finden Sie die Schritte für den Testküchen-Workflow.

Erstellen eines Kochbuchs mit Chef

Verwenden Sie den folgenden Code, um ein Kochbuch zu erstellen.

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

Es folgt die erstellte Kochbuchstruktur als Ausgabe des obigen Codes.

Testen Sie die Konfigurationsdatei für die Küche

.kitchen.yaml Datei

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 - Es gibt die Software an, die die Maschine verwaltet.

Provisioner- Es enthält Angaben zur Funktionsweise des Küchenchefs. Wir verwenden chef_zero, weil es ermöglicht, eine Chef-Serverumgebung auf dem lokalen Computer nachzuahmen. Dies ermöglicht das Arbeiten mit Knotenattributen und Chef-Serverspezifikationen.

Platform - Dies gibt das Zielbetriebssystem an.

Suites- Es definiert, was in der virtuellen Umgebung angewendet werden soll. Hier definieren Sie mehrere Definitionen. Hier definieren Sie die Ausführungsliste, die angibt, welches Rezept ausgeführt werden soll und in welcher Reihenfolge es ausgeführt werden muss.

Ausführen der Befehle nacheinander

Küchenliste

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

Küche erstellen

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

Küche zusammenlaufen

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

Setup testen

Mit dem Küchen-Login wird getestet, ob die Test-VM korrekt bereitgestellt wurde.

$ 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

Endlich beenden

$ exit 
Logout 
Connection to 127.0.0.1 closed.

Setup zerstören

$ 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 ist das Befehlszeilentool von Chef für die Interaktion mit dem Chef-Server. Man verwendet es zum Hochladen von Kochbüchern und zum Verwalten anderer Aspekte von Chef. Es bietet eine Schnittstelle zwischen dem chefDK (Repo) auf dem lokalen Computer und dem Chef-Server. Es hilft bei der Verwaltung -

• Chefknoten
• Cookbook
• Recipe
• Environments
• Cloud-Ressourcen
• Cloud-Bereitstellung
• Installation auf dem Chef-Client auf Chef-Knoten

Knife bietet eine Reihe von Befehlen zum Verwalten der Chef-Infrastruktur.

Bootstrap-Befehle

• Messer Bootstrap [SSH_USER @] FQDN (Optionen)

Client-Befehle

• Messer Client Bulk löschen REGEX (Optionen)
• Messer Client erstellen CLIENTNAME (Optionen)
• Messer Client löschen CLIENT (Optionen)
• Messer Client bearbeiten KUNDE (Optionen)
• Verwendung: C: / opscode / chef / bin / messer (Optionen)
• Messer Client Schlüssel löschen CLIENT KEYNAME (Optionen)
• Messer Client Schlüssel bearbeiten CLIENT KEYNAME (Optionen)
• Messer Client Schlüsselliste CLIENT (Optionen)
• Messer Client Key Show CLIENT KEYNAME (Optionen)
• Messer Kundenliste (Optionen)
• Messer Client neu registrieren KUNDE (Optionen)
• Messer Client Show CLIENT (Optionen)

Befehle konfigurieren

• Messer konfigurieren (Optionen)
• Messer konfigurieren Client-VERZEICHNIS

Kochbuchbefehle

• Messer Kochbuch Bulk löschen REGEX (Optionen)
• Messer Kochbuch COOKBOOK erstellen (Optionen)
• Messer Kochbuch löschen COOKBOOK VERSION (Optionen)
• Messer Kochbuch herunterladen COOKBOOK [VERSION] (Optionen)
• Messer Kochbuch Liste (Optionen)
• Messer Kochbuch Metadaten COOKBOOK (Optionen)
• Messerkochbuch-Metadaten aus DATEI (Optionen)
• Messer Kochbuch Show COOKBOOK [VERSION] [PART] [FILENAME] (Optionen)
• Messerkochbuchtest [COOKBOOKS ...] (Optionen)
• Messer Kochbuch hochladen [COOKBOOKS ...] (Optionen)

Cookbook Site-Befehle

• Messer Kochbuch Website herunterladen COOKBOOK [VERSION] (Optionen)
• Messer Kochbuch Website installieren COOKBOOK [VERSION] (Optionen)
• Messer Kochbuch Site-Liste (Optionen)
• Messer Kochbuch Website Suche QUERY (Optionen)
• Messer Kochbuch Site Share COOKBOOK [KATEGORIE] (Optionen)
• Messer Kochbuch Website zeigen COOKBOOK [VERSION] (Optionen)
• Messer Kochbuch Website nicht teilen COOKBOOK

Data Bag-Befehle

• Messerdatentasche erstellen TASCHE [ARTIKEL] (Optionen)
• Messerdatentasche löschen TASCHE [ARTIKEL] (Optionen)
• Messerdatentasche BAG ITEM bearbeiten (Optionen)
• Messerdatentasche aus Datei BAG FILE | FOLDER [FILE | FOLDER ..] (Optionen)
• Messerdatentaschenliste (Optionen)
• Messerdatentasche zeigen TASCHE [ARTIKEL] (Optionen)

Umgebungsbefehle

• Messerumgebung vergleiche [UMWELT ..] (Optionen)
• Messerumgebung schaffen UMWELT (Optionen)
• Messerumgebung ENVIRONMENT löschen (Optionen)
• Messerumgebung bearbeiten UMWELT (Optionen)
• Messerumgebung aus Datei DATEI [DATEI ..] (Optionen)
• Messerumgebungsliste (Optionen)
• Messerumgebung zeigen UMWELT (Optionen)

Exec-Befehle

• Messer Exec [SCRIPT] (Optionen)

Hilfebefehle

• Messerhilfe [Liste | THEMA]

Indexbefehle

• Messerindex neu erstellen (Optionen)

Knotenbefehle

• Messerknoten Bulk löschen REGEX (Optionen)
• Messerknoten erstellen NODE (Optionen)
• Messerknoten löschen NODE (Optionen)
• Messerknoten bearbeiten NODE (Optionen)
• Messerknoten-Umgebungsset NODE ENVIRONMENT
• Messerknoten aus Datei DATEI (Optionen)
• Messerknotenliste (Optionen)
• Messerknoten run_list add [NODE] [ENTRY [, ENTRY]] (Optionen)
• Messerknoten run_list entferne [NODE] [ENTRY [, ENTRY]] (Optionen)
• Messerknoten run_list set NODE ENTRIES (Optionen)
• Messerknoten zeigen NODE (Optionen)

OSC-Befehle

• Messer osc_user USER erstellen (Optionen)
• Messer osc_user USER löschen (Optionen)
• Messer osc_user USER bearbeiten (Optionen)
• Messer osc_user Liste (Optionen)
• Messer osc_user USER neu registrieren (Optionen)
• Messer osc_user show USER (Optionen)

Pfadbasierte Befehle

• Messer löschen [PATTERN1 ... PATTERNn]
• Messer deps PATTERN1 [PATTERNn]
• Messer Diff MUSTER
• Messer herunterladen MUSTER
• Messer bearbeiten [PATTERN1 ... PATTERNn]
• Messerliste [-dfR1p] [PATTERN1 ... PATTERNn]
• Messershow [PATTERN1 ... PATTERNn]
• Messer Upload MUSTER
• Messer xargs [BEFEHL]

Rohbefehle

• Messer roh REQUEST_PATH

Rezeptbefehle

• Messerrezeptliste [MUSTER]

Rollenbefehle

• Messerrolle Bulk löschen REGEX (Optionen)
• Messerrolle ROLLE erstellen (Optionen)
• Messerrolle ROLLE löschen (Optionen)
• Messerrolle bearbeiten ROLLE (Optionen)
• Messerrolle env_run_list add [ROLE] [ENVIRONMENT] [ENTRY [, ENTRY]] (Optionen)
• Messerrolle env_run_list clear [ROLLE] [UMWELT]
• Messerrolle env_run_list entfernen [ROLLE] [UMWELT] [EINTRÄGE]
• Messerrolle env_run_list ersetzen [ROLE] [ENVIRONMENT] [OLD_ENTRY] [NEW_ENTRY]
• Messerrolle env_run_list set [ROLLE] [UMWELT] [EINTRÄGE]
• Messerrolle aus Datei DATEI [DATEI ..] (Optionen)
• Messerrollenliste (Optionen)
• Messerrolle run_list add [ROLE] [ENTRY [, ENTRY]] (Optionen)
• Messerrolle run_list clear [ROLE]
• Messerrolle run_list entferne [ROLLE] [EINTRAG]
• Messerrolle run_list ersetzen [ROLE] [OLD_ENTRY] [NEW_ENTRY]
• Messerrolle run_list set [ROLE] [ENTRIES]
• Messer Rollenshow ROLLE (Optionen)

Befehle bedienen

• Messer servieren (Optionen)

SSH-Befehle

• Messer ssh QUERY COMMAND (Optionen)

SSL-Befehle

• Messer SSL Check [URL] (Optionen)
• Messer SSL holen [URL] (Optionen)

Statusbefehle

• Messerstatus ABFRAGE (Optionen)

Tag-Befehle

• Messeranhänger erstellen NODE TAG ...
• Messeranhänger löschen NODE TAG ...
• Messeranhänger Liste NODE

Benutzerbefehle

• Messer Benutzer erstellen USERNAME DISPLAY_NAME FIRST_NAME LAST_NAME EMAIL PASSWORD (Optionen)
• Messer Benutzer löschen USER (Optionen)
• Messer Benutzer bearbeiten USER (Optionen)
• Messer Benutzerschlüssel erstellen USER (Optionen)
• Messer Benutzerschlüssel löschen USER KEYNAME (Optionen)
• Messer Benutzerschlüssel bearbeiten USER KEYNAME (Optionen)
• Messer Benutzerschlüsselliste BENUTZER (Optionen)
• Messer Benutzerschlüssel zeigen USER KEYNAME (Optionen)
• Messer Benutzerliste (Optionen)
• Messer Benutzer neu registrieren USER (Optionen)
• Messer Benutzer zeigen USER (Optionen)

Messereinrichtung

Um ein Messer aufzustellen, muss man sich bewegen .chef Verzeichnis und erstellen Sie eine knife.rbim Chef Repo, das Messer über die Konfigurationsdetails informiert. Dies wird ein paar Details enthalten.

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

Im obigen Code verwenden wir den gehosteten Chef-Server, der die folgenden zwei Schlüssel verwendet.

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

Hier teilt Messer.rb dem Messer mit, welche Organisation verwendet werden soll und wo der private Schlüssel zu finden ist. Es teilt dem Messer mit, wo sich der private Schlüssel des Benutzers befindet.

client_key               "#{current_dir}/USER.pem"

Die folgende Codezeile teilt dem Messer mit, dass wir den gehosteten Server verwenden.

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

Mithilfe der Datei window.rb kann das Validierungsmesser jetzt eine Verbindung zum gehosteten Opscode Ihres Unternehmens herstellen.

Chef-Solo ist ein Open-Source-Tool, das lokal ausgeführt wird und die Bereitstellung von Gastcomputern mithilfe von Chef-Kochbüchern ohne die Komplikation einer Chef-Client- und -Serverkonfiguration ermöglicht. Es hilft, Kochbücher auf einem selbst erstellten Server auszuführen.

Bevor Chef-Solo auf dem lokalen Computer ausgeführt werden kann, müssen die folgenden zwei Dateien auf dem lokalen Computer installiert werden.

• Solo.rb - In dieser Datei erfahren Sie, wo Sie Kochbücher, Rollen und Datentaschen finden.

• Node.json - Diese Datei legt bei Bedarf die Ausführungsliste und alle knotenspezifischen Attribute fest.

solo.rb Konfiguration

Im Folgenden finden Sie die Schritte zum Konfigurieren von solo.rb.

Step 1 - Erstellen Sie eine solo.rb-Datei im Chef Repo.

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

Step 2 - Fügen Sie die Datei zu git repo hinzu.

$ git add solo.rb

Step 3 - Erstellen Sie eine node.json-Datei im Chef-Repo mit dem folgenden Inhalt.

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

Step 4 - Holen Sie sich das NTP-Kochbuch mit einem Messer in das Koch-Repo.

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 - Fügen Sie die Datei node.json zu Git hinzu.

$ git add node.json

Step 6 - Commit und Push der Dateien zu 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

Ausführen des Kochbuchs auf dem Knoten

Step 1 - Melden Sie sich bei dem Knoten an, an dem Sie den Chef-Solo bereitstellen möchten.

Step 2 - Klonen Sie das Chef Repo auf die Maschine.

$ git clone $URL_PATH

Step 3 - CD zum Chef Repo.

$ cd chef-repo

Führen Sie abschließend Chef-Solo aus, um den Knoten zu konvergieren.

$ 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 Konfiguriert Chef-Solo so, dass im aktuellen Verzeichnis nach Kochbüchern, Rollen und Datentaschen gesucht wird: im Chef-Repository.

Chef-Solobezieht seine Knotenkonfiguration aus einer JSON-Datei. In unserem Beispiel haben wir es node.json genannt. Wenn Sie mehrere Server verwalten möchten, benötigen Sie für jeden Knoten eine separate Datei. Anschließend führt Chef-Solo nur einen Chef-Lauf aus, der auf den Konfigurationsdaten in solo.rb und node.json basiert.

Kochbücher sind grundlegende Arbeitseinheiten von Chef, die alle Details zu Arbeitseinheiten enthalten und die Konfiguration und den Status jedes Systems ändern können, das als Knoten in der Chef-Infrastruktur konfiguriert ist. Kochbücher können mehrere Aufgaben ausführen. Kochbücher enthalten Werte zum gewünschten Knotenstatus. Dies wird in Chef durch die Verwendung der gewünschten externen Bibliotheken erreicht.

Schlüsselkomponenten eines Kochbuchs

• Recipes
• Metadata
• Attributes
• Resources
• Templates
• Libraries
• Alles andere, was zur Erstellung eines Systems beiträgt

Ein Kochbuch erstellen

Es gibt zwei Möglichkeiten, ein Kochbuch dynamisch zu erstellen.

• Mit dem Befehl chef
• Verwenden des Messerdienstprogramms

Chef Command verwenden

Führen Sie den folgenden Befehl aus, um mit dem Befehl Chef ein leeres Kochbuch zu erstellen.

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)

Die Kochbuchstruktur mit dem Namen VTest wird im Verzeichnis erstellt, und im Folgenden wird die Struktur dafür aufgeführt.

Verwenden des Messer-Dienstprogramms

Verwenden Sie den folgenden Befehl, um ein Kochbuch mit dem Messer-Dienstprogramm zu erstellen.

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

Es folgt die Struktur des Kochbuchs.

Die Funktionen zum Definieren von Kochbuchabhängigkeiten helfen beim Verwalten von Kochbüchern. Diese Funktion wird verwendet, wenn wir die Funktionalität eines Kochbuchs in anderen Kochbüchern verwenden möchten.

Wenn Sie beispielsweise C-Code kompilieren möchten, müssen Sie sicherstellen, dass alle zum Kompilieren erforderlichen Abhängigkeiten installiert sind. Zu diesem Zweck gibt es möglicherweise ein separates Kochbuch, das eine solche Funktion ausführen kann.

Wenn wir Chef-Server verwenden, müssen wir solche Abhängigkeiten in Kochbüchern kennen, die in der Metadatendatei der Kochbücher verlangsamt werden sollten. Diese Datei befindet sich oben in der Kochbuchverzeichnisstruktur. Es enthält Hinweise zum Chef-Server, die beim Bereitstellen von Kochbüchern auf dem richtigen Knoten hilfreich sind.

Funktionen der Datei metadata.rb

• Befindet sich oben in der Kochbuchverzeichnisstruktur.

• Kompiliert, wenn das Kochbuch mit dem Messerbefehl auf den Chef-Server hochgeladen wird.

• Kompiliert mit dem Unterbefehl Messer-Kochbuch-Metadaten.

• Wird automatisch erstellt, wenn der Befehl zum Erstellen eines Messerkochbuchs ausgeführt wird.

Konfiguration von metadata.rb

Es folgt der Standardinhalt einer Metadatendatei.

Rollen in Chef sind eine logische Methode zum Gruppieren von Knoten. Typische Fälle sind Rollen für Webserver, Datenbankserver usw. Sie können eine benutzerdefinierte Ausführungsliste für alle Knoten festlegen und den Attributwert innerhalb der Rollen überschreiben.

Erstellen Sie eine Rolle

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

Sobald wir die Rolle erstellt haben, müssen wir sie auf den Chef-Server hochladen.

Rolle auf Chef Server hochladen

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

Jetzt müssen wir einem Knoten namens Server eine Rolle zuweisen.

Weisen Sie dem Knoten eine Rolle zu

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

Führen Sie den Chef-Client aus

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

Wie es funktioniert

• Definieren Sie eine Rolle in einer Ruby-Datei im Rollenordner des Chef-Repositorys.

• Eine Rolle besteht aus einem Namen und einem Beschreibungsattribut.

• Eine Rolle besteht aus rollenspezifischen Ausführungslisten und rollenspezifischen Attributeinstellungen.

• Für jeden Knoten, der eine Rolle in seiner Ausführungsliste hat, wird die Ausführungsliste der Rolle in eine eigene ausgeführt.

• Alle Rezepte in der Ausführungsliste der Rolle werden auf dem Knoten ausgeführt.

• Die Rolle wird mit dem Befehl Messerrolle aus Datei auf den Chef-Server hochgeladen.

• Die Rolle wird der Knotenlaufliste hinzugefügt.

• Wenn Sie den Chef-Client auf einem Knoten ausführen, dessen Ausführungsliste die Rolle enthält, werden alle in der Rolle aufgeführten Rezepte ausgeführt.

Chef hilft bei der Durchführung der umgebungsspezifischen Konfiguration. Es ist immer eine gute Idee, eine separate Umgebung für Entwicklung, Test und Produktion zu haben.

Chef ermöglicht das Gruppieren von Knoten in separate Umgebungen, um einen geordneten Entwicklungsablauf zu unterstützen.

Eine Umgebung schaffen

Die Erstellung einer Umgebung im laufenden Betrieb kann mit dem Messer-Dienstprogramm erfolgen. Der folgende Befehl öffnet den Standardeditor einer Shell, sodass die Umgebungsdefinition geändert werden kann.

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

Testen einer erstellten Umgebung

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

Listenknoten für alle Umgebungen

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

_Standardumgebung

Jede Organisation beginnt immer mit mindestens einer einzigen Umgebung, der Standardumgebung, die dem Chef-Server immer zur Verfügung steht. Eine Standardumgebung kann ohnehin nicht geändert werden. Änderungen jeglicher Art können nur in der von uns erstellten benutzerdefinierten Umgebung berücksichtigt werden.

Umgebungsattribute

Ein Attribut kann in einer Umgebung definiert und dann zum Überschreiben der Standardeinstellungen im Knoten verwendet werden. Wenn der Chef-Client ausgeführt wird, werden diese Attribute mit den Standardattributen verglichen, die bereits im Knoten vorhanden sind. Wenn die Umgebungsattribute Vorrang vor den Standardattributen haben, wendet der Chef-Client diese Einstellungen und Werte an, wenn der Chef-Client auf jedem Knoten ausgeführt wird.

Ein Umgebungsattribut kann nur entweder default_attribute oder override_attribute sein. Es kann kein normales Attribut sein. Man kann die Methoden default_attribute oder override_attribute verwenden.

Attributtyp

Default - Ein Standardattribut wird immer zu Beginn jedes Chef-Client-Laufs zurückgesetzt und hat die niedrigste Attributpriorität.

Override- Ein Override-Attribut wird immer zu Beginn jedes Chef-Client-Laufs zurückgesetzt und hat eine höhere Attributpriorität als default, force_default und normal. Ein Überschreibungsattribut wird am häufigsten im Rezept definiert, kann aber auch in einer Attributdatei für eine Rolle oder eine Umgebung angegeben werden.

Reihenfolge der Anwendung eines Attributs

Wenn Sie Chef-Client als Daemon ausführen, können Sie den Status aller Knoten zu jedem Zeitpunkt ermitteln. Dies hilft bei der Ausführung des Chef-Clients zu jedem Zeitpunkt.

Voraussetzungen

Der Knoten sollte beim Chef-Server registriert sein und Chef-Client ohne Fehler ausführen.

Chef-Client im Daemon-Modus

Starten Sie Chef-Client im Daemon-Modus, der alle 30 Minuten ausgeführt wird.

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

Im obigen Code - i ermöglicht die Ausführung des Chef-Client im Daemon-Modus auf dem erforderlichen Knoten und 1800 Sekunden definieren, dass der Chef-Client-Daemon alle 30 Minuten ausgeführt werden soll.

Überprüfen des Daemon-Laufs

Überprüfen Sie, ob der Chef-Client als Daemon ausgeführt wird.

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

Der obige Befehl überprüft den laufenden Daemon-Prozess von Chef-Client.

Andere Möglichkeiten

Anstatt Chef-Client als Daemon auszuführen, können wir dasselbe wie a ausführen 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'

Der oben genannte Cron-Job wird alle 15 Minuten ausgeführt.

Kochbücher zu schreiben ist immer schwer. Dies macht es noch schwieriger, da sie lange auf den Chef-Server hochgeladen, eine vagabundierende VM bereitgestellt, überprüft werden, wie sie dort fehlgeschlagen sind, gespült und wiederholt wurden. Es wäre einfacher, wenn wir versuchen könnten, einige Stücke oder Rezepte zu testen, bevor wir all dieses schwere Heben auf einmal machen.

Chef kommt mit Chef-Shell, was im Wesentlichen eine interaktive Ruby-Sitzung mit Chef ist. In der Chef-Shell können wir erstellen -

• Attributes
• Rezepte schreiben
• Chef wird initialisiert

Es wird verwendet, um Teile von Rezepten im laufenden Betrieb auszuwerten, bevor sie auf den Chef-Server hochgeladen und vollständige Kochbücher auf dem Knoten ausgeführt werden.

Shell ausführen

Step 1 - Führen Sie Chef-Shell im Standalone-Modus aus.

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 - Wechseln Sie in der Chef-Shell in den Attributmodus

• chef > attributes_mode

Step 3 - Attributwert einstellen.

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

  • "Kochbuch"

• chef:attributes > quit

  • :attributes

• chef >

Step 4 - Wechseln Sie in den Rezeptmodus.

• chef > recipe_mode

Step 5 - Erstellen Sie eine Dateiressource.

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 - Starten Sie den Chef-Lauf, um die Datei mit dem angegebenen Inhalt zu erstellen.

• 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

Wie es funktioniert

• Chef-Shell beginnt mit einer IRB-Sitzung (Interactive Ruby), die um einige spezifische Funktionen erweitert wurde.

• Es bietet Modi wie Attribute_Mode und Interactive_Mode.

• Es hilft beim Schreiben von Befehlen, die in ein Rezept oder Kochbuch geschrieben sind.

• Es läuft alles in einem interaktiven Modus.

Wir können Chef-Shell in drei verschiedenen Modi ausführen: Standalone mode, Client mode, und Solo mode.

• Standalone mode- Dies ist der Standardmodus. Es werden keine Kochbücher geladen und die Ausführungsliste ist leer.

• Client mode - Hier fungiert die Chef-Shell als Chef-Kunde.

• Solo mode - Hier fungiert die Chef-Shell als Chef-Solo-Kunde.

Wenn das Kochbuch direkt bereitgestellt und auf dem Produktionsserver ausgeführt wird, besteht eine hohe Wahrscheinlichkeit, dass das Kochbuch in der Produktion ausfällt. Der beste Weg, dies zu verhindern, besteht darin, das Kochbuch in der Setup-Umgebung zu testen.

Im Folgenden finden Sie die Schritte zum Testen.

Step 1 - Installieren Sie das Kochbuch mit dem folgenden Befehl.

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

Step 2 - Führen Sie die Testbefehle für das Messerkochbuch im Arbeitskochbuch aus.

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

Step 3 - Brechen Sie etwas im Kochbuch und testen Sie es erneut.

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 - Führen Sie den Messertestbefehl erneut aus.

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:

Arbeitsmethode

Der Messer-Kochbuchtest führt eine Ruby-Syntaxprüfung für alle Ruby-Dateien im Kochbuch sowie für alle ERB-Vorlagen durch. Es durchläuft Ruby-Dateien und führt Ruby aus–cgegen jeden von ihnen. Rubin–c Überprüft die Syntax des Skripts und wird beendet, ohne es auszuführen.

Nachdem Sie alle Ruby-Dateien durchgesehen haben, durchläuft der Messerkochbuchtest alle ERB-Vorlagen und -Pipes, die redundante Version, die von erstellt wurde –x durch Ruby –c.

Einschränkungen

Der Messerkochbuchtest führt nur eine einfache Syntaxprüfung der Ruby-Dateien und ERB-Vorlagen durch. Mit ChefSpec und Testküche können wir eine vollständige Testfahrt durchführen.

Gute Kochbücher ohne Probleme zu schreiben, ist eine ziemlich schwierige Aufgabe. Es gibt jedoch Möglichkeiten, wie Sie die Fallstricke identifizieren können. Das Markieren im Kochbuch ist möglich. Foodcritic ist eine der besten Methoden zur Archivierung, mit der versucht wird, mögliche Probleme mit der Logik und dem Stil von Kochbüchern zu identifizieren.

Lebensmittelkritisches Setup

Step 1 - Foodcritic Edelstein hinzufügen.

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

Step 2 - Installieren Sie den Edelstein.

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

Foodcritic Gem

Step 1 - Führen Sie Foodcritic im Kochbuch aus.

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 - Erstellen Sie einen detaillierten Bericht.

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|

Arbeitsmethode

Foodcritic definiert eine Reihe von Regeln und überprüft jeweils die Rezeptagenten. Es enthält mehrere Regeln für verschiedene Bereiche: Stile, Verbundenheit, Attribute, Zeichenfolge, Wahrscheinlichkeit, Suche, Dienste, Dateien, Metadaten usw.

Test Driven Development (TDD)ist eine Möglichkeit, einen Komponententest zu schreiben, bevor ein tatsächlicher Rezeptcode geschrieben wird. Der Test sollte real sein und validieren, was ein Rezept bewirkt. Es sollte eigentlich scheitern, da kein Rezept entwickelt wurde. Sobald das Rezept entwickelt ist, sollte der Test bestehen.

ChefSpec basiert auf dem beliebten RSpec-Framework und bietet eine maßgeschneiderte Syntax zum Testen des Chef-Rezepts.

ChefSpec erstellen

Step 1 - Erstellen Sie eine Gem-Datei mit dem ChefSpec-Gem.

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

Step 2 - Installieren Sie den Edelstein.

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 - Erstellen Sie ein Spezifikationsverzeichnis.

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

Step 4 - Erstellen Sie eine Spezifikation

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 - Überprüfen Sie 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 - Standardrezept für Kochbücher bearbeiten.

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

Step 7 - Erstellen Sie eine Vorlagendatei.

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

Step 8 - Führen Sie die rspec erneut aus.

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

Wie es funktioniert

Damit es funktioniert, müssen wir zuerst die Basisinfrastruktur für die Verwendung von RSpec mit Chef einrichten. Dann müssen wir ChefSpec Ruby Gem und das Kochbuch benötigt ein Verzeichnis namens spec, in dem alle Tests gespeichert werden.

Testküche ist das Integrationstest-Framework von Chef. Es ermöglicht das Schreiben von Tests, die ausgeführt werden, nachdem die VM mithilfe des Kochbuchs instanziiert und konvergiert wurde. Die Tests werden auf einer VM ausgeführt und können überprüfen, ob alles wie erwartet funktioniert.

Dies ist ein Knotenvertrag mit ChefSpec, der nur einen Chef-Lauf simuliert. Test Kitchen startet einen echten Knoten und führt Chef darauf aus.

Einrichten

Dazu muss Vagrant auf der Maschine installiert sein, was bei der Verwaltung einer virtuellen Maschine hilfreich ist. Dann muss das Bücherregal installiert und mit Vagrant verbunden sein, um die Kochbuchabhängigkeiten zu verwalten.

Step 1 - Standardrezept im Kochbuch bearbeiten.

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

Step 2 - Kochbuchattribute bearbeiten.

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

Step 3 - Bearbeiten Sie die Gem-Datei, um die erforderlichen Ruby-Gems zu installieren.

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

Step 4 - Installieren Sie den erforderlichen Ruby-Edelstein.

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 - Erstellen Sie die Datei .kitchen.yml im Kochbuch.

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 - Erstellen Sie ein Testverzeichnis im Kochbuch.

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

Step 7 - Erstellen Sie ein Testkochbuch für Integrationstests.

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 - Bearbeiten Sie das Standardrezept für Testkochbücher.

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

Step 9 - Erstellen Sie die Minitest-Spezifikation im Kochbuch.

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 - Bearbeiten Sie die Berksdatei Ihres Hauptkochbuchs.

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"

Setup testen

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 Zeigt Details zu allen Knoten an, die ein bestimmtes Kochbuch verwenden, bevor es auf den Chef-Server hochgeladen wird.

Anfangen

Um loszulegen, muss ein Messer-Preflight-Edelstein installiert sein.

Step 1 - Definieren Sie den Pfad in der Gem-Datei.

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

Step 2 - Führen Sie den Bundler aus, um den Messer-Preflight-Edelstein zu installieren.

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

Arbeitsmethode

Führen Sie das Messer-Preflight für das angegebene Kochbuch durch.

Wir können den Preflight-Befehl ausführen, um herauszufinden, welche Knoten und Rollen das angegebene Kochbuch in ihren erweiterten Ausführungslisten haben.

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

Es gibt mehrere Möglichkeiten, wie ein Kochbuch auf dem Knoten ausgeführt werden kann.

• Sie können das Kochbuch direkt einem Knoten zuweisen, indem Sie es zur Ausführungsliste des Knotens hinzufügen.

• Sie können der Rolle ein Kochbuch hinzufügen und die Rolle zur Ausführungsliste des Knotens hinzufügen.

• Sie können die Rolle zur Ausführungsliste einer anderen Rolle hinzufügen und diese andere Rolle zur Ausführungsliste des Knotens hinzufügen.

• Ein Kochbuch kann eine Abhängigkeit von einem anderen verwendeten Kochbuch sein.

Unabhängig davon, wie ein Kochbuch in der Ausführungsliste eines Knotens landet, wird es mit dem Messer-Preflight-Befehl abgefangen, wenn Chef alle erweiterten Listen von Rollen und Rezepten in Knotenattributen speichert. Der Messer-Preflight-Befehl gibt eine Suche nach genau diesen Knotenattributen aus.

Um den Chef-Client-Lauf zu testen, muss Chef-Client für die Verwendung des gehosteten Chefs oder des eigenen gehosteten Servers konfiguriert sein.

Chef-Client im Debug-Modus ausführen

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

Überprüfen des Ergebnisses des letzten Chef-Client-Laufs

Um den letzten Chef-Client-Lauf zu überprüfen, insbesondere Fehlerprobleme bei der Entwicklung eines neuen Kochbuchs, müssen wir wissen, was genau schief gelaufen ist. Obwohl Chefkoch alles in stdout druckt, möchten Sie möglicherweise das Debug-Protokoll erneut anzeigen.

Wenn wir testen möchten, benötigen wir ein kaputtes Kochbuch, das beim Kompilieren fehlschlägt.

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:

Für weitere Details können wir uns den Stacktrace ansehen.

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'

Attribute sind die Schlüsselkomponenten für die dynamische Konfiguration von Kochbüchern. Mithilfe von Attributen können die Autoren das Kochbuch konfigurierbar machen. Durch Überschreiben der in Kochbüchern festgelegten Standardwerte kann der Benutzer seine eigenen Werte einfügen.

Step 1 - Erstellen Sie eine Standarddatei für Kochbuchattribute und fügen Sie ihr ein Standardattribut hinzu.

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

Step 2 - Definieren Sie das Attribut im Rezept.

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 - Hochladen des geänderten Kochbuchs.

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

Step 4 - Chef-Client des definierten Knotens ausführen.

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

Arbeitsmethode

Chef lädt alle Attribute aus der Attributdatei, bevor sie ausgeführt werden. Die Attribute werden mit dem Knotenobjekt gespeichert. Man kann auf alle Attribute zugreifen, die mit dem Knotenobjekt in Rezepten gespeichert sind, und ihre aktuellen Werte abrufen.

Chefkoch hat eine eingeschränkte Struktur, beginnend mit der Standardeinstellung, die dann niedrig ist, dann normal wird (was mit dem Set verbunden ist) und dann überschreibt. Die im Rezept festgelegte Attributebene hat Vorrang vor derselben in einer Attributdatei festgelegten Ebene.

Überschreiben des Attributs auf Knoten- und Umgebungsebene

In Rollen oder Umgebungen definierte Attribute haben die höchste Priorität.

Step 1 - Erstellen Sie eine Rolle.

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 - Laden Sie die Rolle auf den Chef-Server hoch.

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

Step 3 - Weisen Sie die Rolle einem Knoten zu.

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

Step 4 - Führen Sie den Chef-Client aus.

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

In der Infrastruktur configuration managementdreht sich alles darum, wie gut man die Hosts konfiguriert. Im Allgemeinen werden alle Konfigurationen mithilfe der Konfigurationsdateien durchgeführt. Chef verwendet Vorlagen, um die Konfigurationsdatei mit dynamischen Werten zu füllen.

Chef stellt Vorlagen als Ressource zur Verfügung, die im Rezept verwendet werden können. Die dynamischen Werte von Konfigurationsdateien können aus Datentaschen, Attributen abgerufen oder sogar berechnet werden, indem sie an die Vorlage übergeben werden.

Wie benutzt man es?

Step 1 - Fügen Sie die Vorlage zum Rezept hinzu.

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 - Hinzufügen ERB Vorlagendatei.

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

Step 3 - Laden Sie das geänderte Kochbuch auf den Chef-Server hoch.

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 - Überprüfen Sie den Inhalt der hochgeladenen Datei.

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!

Arbeitsablauf

Chefkoch verwendet Erubis als Vorlagensprache. Es ermöglicht das Einbetten von reinem Ruby-Code in spezielle Symbole in den Vorlagen.

• <% =%> wird verwendet, wenn Sie den Wert einer Variablen oder eines Ruby-Ausdrucks in die generierte Datei drucken möchten.

• <% -%> wird verwendet, wenn Sie Ruby-Logik in Ihre Vorlagendatei einbetten möchten. Wir verwenden es, um unseren Ausdruck viermal zu wiederholen.

Wenn Sie in Chef einfache Rezepte erstellen müssen, können Sie die in Chef verfügbaren Ressourcen wie Vorlagen, remote_file und Dienste verwenden. Wenn die Rezepte jedoch aufwändiger werden, sind fortgeschrittene Techniken erforderlich, wie z. B. bedingte Anweisungen, um Teile des Rezepts unter bestimmten Bedingungen auszuführen. Dies ist die Fähigkeit, einfaches Ruby mit Chef Domain Specific Language (DSL) zu mischen.

Wie benutzt man es?

Starten Sie Chef Shell auf einem beliebigen Knoten im Client-Modus, um auf den Chef-Server zugreifen zu können.

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>

Grundbedingungen mit Chef DSL

Sortieren Sie Knoten mit einfachem Ruby nach Namen.

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

Durchlaufen Sie die Knoten und drucken Sie ihr Betriebssystem.

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

Installieren Sie mehrere Ruby-Edelsteine ​​mithilfe eines Arrays, einer Schleife und einer Zeichenfolgenerweiterung, um die Edelsteinnamen zu erstellen.

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

Arbeitsmethode

Chef-Rezepte sind Ruby-Dateien, die im Rahmen des Chef-Laufs ausgewertet werden. Sie können einfachen Ruby-Code wie if-Anweisungen und Schleifen sowie Chef-DSL-Elemente wie Ressourcen enthalten.

Innerhalb des Rezepts kann man einfach Ruby-Variablen deklarieren und ihr Werte zuweisen.

Rezepte sind die Schlüsselbausteine ​​des Kochbuchs, bei dem es sich im Grunde um Ruby-Code handelt. Es ist möglich, alle Ruby-Sprachfunktionen im Chef-Rezept zu verwenden. Die meiste Zeit reicht die eingebaute Ruby-Funktionalität aus, aber manchmal muss man möglicherweise zusätzliche Ruby-Edelsteine ​​verwenden. Zum Beispiel, wenn Sie über das Rezept selbst auf die MySQL-Datenbank zugreifen müssen.

Das Kochrezept hat die Fähigkeit, die erforderlichen Rubinsteine ​​zu erhalten, um sie innerhalb desselben Rezepts zu verwenden.

Verwenden von iptable Gem im angegebenen Rezept

Step 1 - Bearbeiten Sie das Standardrezept des Kochbuchs und installieren Sie den Edelstein, der im Rezept verwendet werden soll.

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 - Laden Sie das geänderte Kochbuch auf den Chef-Server hoch.

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

Step 3 - Ausführen des Chef-Clients, um die Ausgabe anzuzeigen.

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

Arbeitsmethode

Die Schritte zum Ausführen des Chefs bestehen aus der Kompilierungsphase, in der alle Ressourcen kompiliert werden, und einer Ausführungsphase, in der der Chef die Ressourcenanbieter ausführt, um den Knoten in den gewünschten Zustand zu bringen. Wenn Sie einen bestimmten Ruby-Edelstein im Kochbuch benötigen, müssen Sie den Edelstein während der Komplikationsphase installieren.

Die chef_gem-Ressource wird genau das Gleiche tun, und in Chef ist Omnibus die einzige Möglichkeit, zu arbeiten. Seine Hauptfunktion besteht darin, dem Küchenchef selbst Edelsteine ​​zur Verfügung zu stellen.

Libraries in Chef bietet einen Ort, an dem kompilierte Logik zusammengefasst werden kann, damit die Kochbuchrezepte ordentlich und sauber bleiben.

Bibliothek erstellen

Step 1 - Erstellen Sie eine Hilfsmethode in der Bibliothek des Kochbuchs.

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

Step 2 - Verwenden Sie die Hilfsmethode.

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 - Laden Sie das geänderte Kochbuch auf den Chef Server hoch.

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

Testen der Bibliothek

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

Arbeitsmethode

Der Code der Chefbibliothek kann die Klasse chef :: Recipe öffnen und neue Methoden hinzufügen, wie in Schritt 1 beschrieben. Dieser Schritt ist nicht der sauberste, aber der einfachste Weg, dies zu tun.

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

Empfohlene Vorgehensweise

Sobald wir die Chef :: Rezeptklasse öffnen, gibt es Änderungen, die verschmutzt werden. Als bewährte Methode ist es immer besser, eine neue Unterklasse in die Bibliothek einzuführen und eine Methode als Klassenmethode zu definieren. Dadurch wird vermieden, dass der Namespace chef :: prescription abgerufen wird.

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

Wir können die Methode innerhalb des Rezepts wie verwenden

IPAddress.netmask(ip)

Definition kann als logische Methode zum Gruppieren von Ressourcen definiert werden, die immer wieder verwendet werden. In diesem Ablauf gruppieren wir die Ressourcen und geben ihnen einen Namen, um die Lesbarkeit definierter Kochbücher wiederherzustellen.

Dazu sollten wir ein Rezept haben. In diesem Fall verwenden wir test_cookbook und eine Ausführungsliste von Knoten, die das Kochbuch enthält.

Definition erstellen

Step 1 - Erstellen Sie eine neue Definitionsdatei im Definitionsordner für Kochbücher.

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 - Verwenden Sie eine Definition im Standardrezept des Kochbuchs.

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

Step 3 - Laden Sie das Kochbuch auf den Kochserver hoch.

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

Step 4 - Führen Sie den Chef-Client auf dem gewünschten Knoten aus.

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]

Definitionen in Kochbüchern sind wie Mikros, die die Ressourcen gruppieren und ihnen einen Namen geben. Eine Definition hat einen Namen, anhand dessen man ihnen sagen kann, von welchem ​​innerhalb des Rezepts aufgerufen werden kann, und es gibt eine Liste von Perimetern.

In der Definition haben wir Parameter, die in unserem Code wie folgt aussehen.

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

Es kann im Standardrezept wie folgt verwendet werden.

capistrano_deploy_dirs do 
   deploy_to "/srv"` 
end

Die Umgebungsvariable ist eine wichtige Methode, um das Chef-Rezept erfolgreich auf einem bestimmten Knoten auszuführen. Es gibt mehrere Möglichkeiten, dies entweder manuell einzurichten oder mithilfe eines Shell-Skripts zu verwenden. Hier müssen wir sie per Rezept einstellen.

Dazu benötigen wir ein Kochbuch. Wir würden test_cookbook und eine Ausführungsliste verwenden, die test_cookbook enthält.

Einstellen der Umgebungsvariablen mithilfe des Chef-Rezepts

Step 1 - Aktualisieren Sie das Standardrezept des Kochbuchs mit einer Umgebungsvariablen.

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 - Laden Sie das aktualisierte Kochbuch auf den Server hoch.

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

Step 3 - Ausführen des Chef-Clients zum Erstellen einer temporären Datei.

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

Variable validieren

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

Arbeitsmethode

Ruby macht die aktuelle Umgebungsvariable über ENV verfügbar –a Hash zum Lesen und Ändern der Umgebungsvariablen.

Ressource ausführen

Wir können die Ausführungsressource verwenden, um dasselbe im Standardrezept des Kochbuchs zu tun.

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- Wenn Sie eine Umgebungsvariable mit ENV festlegen, wird diese Variable während des gesamten Chef-Laufs verfügbar. Wenn Sie es dagegen an die Ausführungsressource übergeben, wird es nur für diesen einen Befehl verfügbar, der von der Ressource ausgeführt wird.

Chef-Datentaschen können als willkürliche Sammlung von Daten definiert werden, die mit Kochbüchern verwendet werden können. Die Verwendung von Datentaschen ist sehr hilfreich, wenn Sie keine Attribute in Rezepten fest codieren oder Attribute in Kochbüchern speichern möchten.

Arbeitsmethode

Im folgenden Setup versuchen wir, mit der http-Endpunkt-URL zu kommunizieren. Dazu müssen wir einen Datenbeutel erstellen, der die Endpunkt-URL-Details enthält und in unserem Rezept verwendet.

Step 1 - Erstellen Sie ein Verzeichnis für unsere Datentasche.

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

Step 2- Erstellen Sie ein Datenbeutelelement für den Anforderungsfach. Man muss sicherstellen, dass man eine definierte requestBin-URL verwendet.

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

Step 3 - Erstellen Sie eine Datentasche auf dem Chef-Server

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

Step 4 - Laden Sie die Datentasche auf den Chef-Server hoch.

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

Step 5 - Aktualisieren Sie das Standardrezept des Kochbuchs, um das erforderliche Kochbuch aus einer Datentasche zu erhalten.

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 - Laden Sie das geänderte Kochbuch auf den Chef-Server hoch.

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

Step 7 - Führen Sie den Chef-Client auf dem Knoten aus, um zu überprüfen, ob der http-Anforderungsbehälter ausgeführt wird.

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

Wie es funktioniert

Data Bag ist eine benannte Sammlung von Strukturdateneinträgen. Man muss die Dateneingabe definieren und das Datenbeutelelement in der JSON-Datei aufrufen. Man kann auch innerhalb der Rezepte nach Datenbeuteln suchen, um die in den Datenbeuteln gespeicherten Daten zu verwenden.

Wir haben eine Datentasche namens Hooks erstellt. Ein Datentasche ist ein Verzeichnis im Chef-Repository. Wir haben Messer verwendet, um es auf dem Server zu erstellen.

Unter bestimmten Umständen ist es nicht möglich, den Server unter die volle Kontrolle von Chef zu stellen. In solchen Fällen muss möglicherweise über Skripte auf Werte in Chef-Datentaschen zugegriffen werden. Dazu muss man Datenbeutelwerte in einer JSON-Datei speichern und das hinzugefügte Skript auf diese Werte zugreifen lassen.

Dafür braucht man ein Kochbuch. In unserem Fall würden wir test_cookbook wie zuvor verwenden und sollten die Ausführungsliste des Knotens einschließlich der Definition von test_cookbook enthalten.

Arbeitsmethode

Step 1 - Erstellen Sie eine Datentasche.

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

Step 2 - Erstellen Sie einen Datentaschenartikel.

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

Step 3 - Aktualisieren Sie den Datentaschenartikel.

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

Verwendung im Kochbuch

Step 1 - Sie müssen eine JSON-Datei mit Datenbeutelwerten mithilfe des obigen Kochbuchs erstellen, damit externe Skripts auf diese Werte zugreifen können.

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 - Laden Sie test_cookbook auf den Chef-Server hoch.

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

Step 3 - Führen Sie den Chef-Client auf dem Knoten aus.

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 - Überprüfen des Inhalts der generierten JSON-Datei.

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

Workflow von Skripten

Im obigen Befehl die Dateiressource, die wir verwendet haben und die eine JSON-Datei innerhalb der erstellt /etcVerzeichnis ist im Standardkochbuch definiert. Der Dateiinhalt wird mithilfe der Methode data_bag_item direkt aus dem Datentasche abgerufen. Wir greifen über das Data-Bag-Element auf die Host-Werte zu und konvertieren sie in JSON. Die Dateiressource verwendet die JSON-konvertierten Werte als Inhalt und schreibt sie auf die Festplatte.

Plattformübergreifende Kochbücher sind solche Kochbücher, die eine zugrunde liegende Umgebung annehmen, in der sie ausgeführt werden sollen. Chef bietet eine Vielzahl von Funktionen, die beim Schreiben plattformübergreifender Kochbücher helfen, die auf jedem Betriebssystem ausgeführt werden können, auf dem es bereitgestellt werden soll. Dies hilft einem Entwickler, ein vollständig funktionsfähiges Kochbuch zu schreiben.

Dazu benötigen wir ein Kochbuch. In unserem Fall handelt es sich um test_cookbook und eine Ausführungsliste mit der Kochbuchdefinition.

Arbeitsmethode

Das Abrufen der Plattformdetails der Knoten und das Ausführen der bedingten Logik in unserem Kochbuch hängt von der Plattform ab. In unserem Fall werden wir es für Ubuntu testen.

Step 1 - Protokollieren Sie eine Nachricht, wenn der Knoten Ubuntu ist.

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

Step 2 - Laden Sie das Kochbuch auf den Chef-Server hoch.

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

Step 3 - Führen Sie den Chef-Client auf dem Knoten aus.

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

Wenn Sie nicht an einer bestimmten Plattform interessiert sind, sondern nur wissen müssen, welche deklarative verwendet wird, kann alternativ die folgende Anweisung verwendet werden.

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

Wenn Sie das geänderte Kochbuch hochladen und den Chef-Client auf dem Ubuntu-Knoten ausführen, wird das folgende Ergebnis angezeigt.

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

Workflow von Skripten

Im obigen Befehl erkennt Ohai den aktuellen Status des Betriebssystems des Knotens und speichert ihn als Plattformattribut mit dem Knotenobjekt.

node['platform']

Oder Sie können die Syntax des Methodenstils verwenden -

node.platform

Plattformspezifische Werte festlegen

Um plattformspezifische Werte festzulegen, bietet chef praktische Methoden value_for_platform und value_for_platform_family an. Sie können verwendet werden, um komplexe case-Anweisungen zu vermeiden und stattdessen einen einfachen Hash zu verwenden.

Beispiel Kochbuch

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

Im obigen Beispiel ist der Befehl wie definiert betriebssystemspezifisch.

• Für Debian funktioniert "runningvdir-start"
• Für Ubuntu funktioniert "start runsvdir"
• Für Gentoo funktioniert "/etc/init.d/runit-start"

Die Chef-Ressource repräsentiert einen Teil des Betriebssystems in seinem gewünschten Zustand. Es handelt sich um eine Anweisung der Konfigurationsrichtlinie, die den gewünschten Status eines Knotens beschreibt, zu dem die aktuelle Konfiguration zur Verwendung von Ressourcenanbietern verwendet werden soll. Mithilfe des Ohai-Mechanismus von Chef können Sie den aktuellen Status der Zielmaschine ermitteln. Es hilft auch bei der Definition der Schritte, die erforderlich sind, um den Zielcomputer in diesen Zustand zu versetzen. Die Ressourcen sind in Rezepten zusammengefasst, die die Arbeitskonfiguration beschreiben.

Im Fall von Chef ordnet chef :: Platform die Anbieter und Plattformversionen jedes Knotens zu. Zu Beginn jedes Chef-Client-Laufs sammelt der Chef-Server die Details des aktuellen Status aller Maschinen. Später verwendet der Chef-Server diese Werte, um den richtigen Anbieter zu identifizieren.

Ressourcensyntax

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

In der obigen Syntax ist 'Typ' der Ressourcentyp und 'Name' der Name, den wir verwenden werden. Im Block 'do' und 'end' haben wir das Attribut dieser Ressource und die Aktion, die wir für diese bestimmte Ressource ausführen müssen.

Jede Ressource, die wir im Rezept verwenden, verfügt über eigene Aktionen, die im Block 'do' und 'end' definiert sind.

Beispiel

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

Alle Ressourcen haben einen gemeinsamen Satz von Funktionen, Aktionen, Eigenschaften, bedingter Ausführung, Benachrichtigung und relevantem Aktionspfad.

Aktionen	Das :nothing Aktion kann mit jeder Ressource oder benutzerdefinierten Ressource verwendet werden.
Eigenschaften	Die Eigenschaften ignore_failure, provider, retries, retry_delay und support können mit jeder Ressource oder benutzerdefinierten Ressourcen verwendet werden.
Wachen	Die bedingten Ausführungen not_if und only_if können verwendet werden, um bestimmte Ressourcen zusätzlich zu schützen, sodass sie nur ausgeführt werden, wenn die Bedingung erfüllt ist.
Wachdolmetscher	Wertet einen Zeichenfolgenbefehl mit a aus script-basierte Ressource: bash, csh, perl, powershell_script, python, oder ruby.
Benachrichtigungen	Die Benachrichtigungen für Benachrichtigungen und Abonnements können für jede Ressource verwendet werden.
Relative Pfade	Der relative Pfad # {ENV ['HOME']} kann mit jeder Ressource verwendet werden.
Windows-Dateisicherheit	Das template, file, remote_file, cookbook_file, directory, und remote_directory Ressourcen unterstützen die Verwendung von Vererbungs- und Zugriffssteuerungslisten (ACLs) in Rezepten.
In der Kompilierungsphase ausführen	Manchmal muss eine Ressource vor jeder anderen Ressource oder nachdem alle Ressourcen zur Ressourcensammlung hinzugefügt wurden, ausgeführt werden.

Verfügbare Ressourcen

apt_package

Verwenden Sie die apt_package Ressource zum Verwalten von Paketen für die Debian- und Ubuntu-Plattformen.

Bash

Verwenden Sie die bashRessource zum Ausführen von Skripten mit dem Bash-Interpreter. Diese Ressource kann auch alle Aktionen und Eigenschaften verwenden, die für die verfügbar sindexecuteRessource. Befehle, die mit dieser Ressource ausgeführt werden, sind (von Natur aus) nicht idempotent, da sie normalerweise nur für die Umgebung gelten, in der sie ausgeführt werden. Verwenden Sie not_if und only_if, um diese Ressource vor Idempotenz zu schützen.

Stapel

Verwenden Sie die batchRessource zum Ausführen eines Batch-Skripts mit dem Interpreter cmd.exe. Dasbatch Ressource erstellt und führt eine temporäre Datei aus (ähnlich wie die script Ressource verhält sich), anstatt den Befehl inline auszuführen.

Diese Ressource erbt Aktionen (: run und: nichts) und Eigenschaften (erstellt, cwd, Umgebung, Gruppe, Pfad, Zeitlimit und Benutzer) von der executeRessource. Befehle, die mit dieser Ressource ausgeführt werden, sind (von Natur aus) nicht idempotent, da sie normalerweise nur für die Umgebung gelten, in der sie ausgeführt werden. Verwendennot_if und only_if um diese Ressource vor Idempotenz zu schützen.

bff_package

Verwenden Sie die bff_package Ressource zum Verwalten von Paketen für die AIX-Plattform mithilfe der installpNützlichkeit. Wenn ein Paket aus einer lokalen Datei installiert wird, muss es dem Knoten mithilfe von hinzugefügt werdenremote_file oder cookbook_file resources.

chef_gem

Verwenden Sie die chef_gemRessource zum Installieren eines Edelsteins nur für die Instanz von Ruby, die dem Chef-Client gewidmet ist. Wenn ein Gem aus einer lokalen Datei installiert wird, muss es dem Knoten mit dem hinzugefügt werdenremote_file oder cookbook_file Ressourcen.

Das chef_gem Die Ressource arbeitet mit denselben Eigenschaften und Optionen wie die gem_packageRessource, akzeptiert jedoch nicht die Eigenschaft gem_binary, da immer die CurrentGemEnvironment verwendet wird, unter der der Chef-Client ausgeführt wird. Zusätzlich zur Ausführung von Aktionen ähnlich dergem_package Ressource, die chef_gem Ressource macht das oben genannte.

cookbook_file

Verwenden Sie die cookbook_file Ressource zum Übertragen von Dateien aus einem Unterverzeichnis von COOKBOOK_NAME / files / in einen angegebenen Pfad auf einem Host, auf dem ChefClient ausgeführt wird.

Die Datei wird entsprechend der Dateispezifität ausgewählt, sodass je nach Hostname, Hostplattform (Betriebssystem, Distribution oder entsprechend) oder Plattformversion unterschiedliche Quelldateien verwendet werden können. Dateien, die sich im Unterverzeichnis COOKBOOK_NAME / files / default befinden, können auf jeder Plattform verwendet werden.

Cron

Verwenden Sie die Cron-Ressource, um Cron-Einträge für die zeitbasierte Jobplanung zu verwalten. Die Eigenschaften für einen Zeitplan sind standardmäßig *, wenn sie nicht angegeben werden. Die Cron-Ressource erfordert Zugriff auf ein Crontab-Programm, normalerweise Cron.

Csh

Verwenden Sie die csh-Ressource, um Skripts mit dem csh-Interpreter auszuführen. Diese Ressource kann auch alle Aktionen und Eigenschaften verwenden, die der Ausführungsressource zur Verfügung stehen.

Befehle, die mit dieser Ressource ausgeführt werden, sind (von Natur aus) nicht idempotent, da sie normalerweise nur für die Umgebung gelten, in der sie ausgeführt werden. Verwenden Sie not_if und only_if, um diese Ressource vor Idempotenz zu schützen.

Bereitstellen

Verwenden Sie die deployRessource zum Verwalten und Steuern von Bereitstellungen. Dies ist eine beliebte Ressource, aber auch komplex. Sie verfügt über die meisten Eigenschaften, mehrere Anbieter, die zusätzliche Komplexität von Rückrufen sowie vier Attribute, die Layoutänderungen innerhalb eines Rezepts unterstützen.

Verzeichnis

Verwenden Sie die directoryRessource zum Verwalten eines Verzeichnisses, bei dem es sich um eine Hierarchie von Ordnern handelt, die alle auf einem Computer gespeicherten Informationen enthält. Das Stammverzeichnis ist die oberste Ebene, unter der der Rest des Verzeichnisses organisiert ist.

Das directoryDie Ressource verwendet die Eigenschaft name, um den Pfad zu einem Speicherort in einem Verzeichnis anzugeben. In der Regel ist die Berechtigung zum Zugriff auf diesen Speicherort im Verzeichnis erforderlich.

dpkg_package

Verwenden Sie die dpkg_package Ressource zum Verwalten von Paketen für die dpkgPlattform. Wenn ein Paket aus einer lokalen Datei installiert wird, muss es dem Knoten mithilfe von hinzugefügt werdenremote_file oder cookbook_file Ressourcen.

easy_install_package

Verwenden Sie die easy_install_package Ressource zum Verwalten von Paketen für die Python-Plattform.

Env

Verwenden Sie die envRessource zum Verwalten von Umgebungsschlüsseln in Microsoft Windows. Nachdem ein Umgebungsschlüssel festgelegt wurde, muss Microsoft Windows neu gestartet werden, bevor der Umgebungsschlüssel für den Taskplaner verfügbar ist.

erl_call

Verwenden Sie die erl_callRessource zum Herstellen einer Verbindung zu einem Knoten in einem verteilten Erlang-System. Befehle, die mit dieser Ressource ausgeführt werden, sind (von Natur aus) nicht idempotent, da sie normalerweise nur für die Umgebung gelten, in der sie ausgeführt werden. Verwenden Sie not_if und only_if, um diese Ressource vor Idempotenz zu schützen.

Ausführen

Verwenden Sie die executeRessource zum Ausführen eines einzelnen Befehls. Befehle, die mit dieser Ressource ausgeführt werden, sind (von Natur aus) nicht idempotent, da sie normalerweise nur für die Umgebung gelten, in der sie ausgeführt werden. Verwendennot_if und only_if um diese Ressource vor Idempotenz zu schützen.

Datei

Verwenden Sie die file Ressource zum Verwalten der Dateien direkt auf einem Knoten.

freebsd_package

Verwenden Sie die freebsd_package Ressource zum Verwalten von Paketen für die FreeBSD-Plattform.

gem_package

Verwenden Sie die gem_packageRessource zum Verwalten von Edelsteinpaketen, die nur in Rezepten enthalten sind. Wenn ein Paket aus einer lokalen Datei installiert wird, muss es dem Knoten mithilfe von hinzugefügt werdenremote_file oder cookbook_file Ressourcen.

Git

Verwenden Sie die gitRessource zum Verwalten von Quellcodeverwaltungsressourcen, die in einem Git-Repository vorhanden sind. Git-Version 1.6.5 (oder höher) ist erforderlich, um alle Funktionen der Git-Ressource nutzen zu können.

Gruppe

Verwenden Sie die group Ressource zum Verwalten einer lokalen Gruppe.

homebrew_package

Verwenden Sie die homebrew_package Ressource zum Verwalten von Paketen für die Mac OS X-Plattform.

http_request

Verwenden Sie die http_requestRessource zum Senden einer HTTP-Anforderung (GET, PUT, POST, DELETE, HEAD oder OPTIONS) mit einer beliebigen Nachricht. Diese Ressource ist häufig nützlich, wenn benutzerdefinierte Rückrufe erforderlich sind.

Ifconfig

Verwenden Sie die ifconfig Ressource zum Verwalten von Schnittstellen.

ips_package

Verwenden Sie die ips_package Ressource zum Verwalten von Paketen (mithilfe von Image Packaging System (IPS)) auf der Solaris 11-Plattform.

Ksh

Verwenden Sie die kshRessource zum Ausführen von Skripten mit dem Korn-Shell-Interpreter (ksh). Diese Ressource kann auch alle Aktionen und Eigenschaften verwenden, die der Ausführungsressource zur Verfügung stehen.

Befehle, die mit dieser Ressource ausgeführt werden, sind (von Natur aus) nicht idempotent, da sie normalerweise nur für die Umgebung gelten, in der sie ausgeführt werden. Verwenden Sie not_if und only_if, um diese Ressource vor Idempotenz zu schützen.

Verknüpfung

Verwenden Sie die link Ressource zum Erstellen symbolischer oder fester Links.

Log

Verwenden Sie die logRessource zum Erstellen von Protokolleinträgen. Die Protokollressource verhält sich wie jede andere Ressource: Sie wird während der Kompilierungsphase in die Ressourcensammlung integriert und dann während der Ausführungsphase ausgeführt. (Um einen Protokolleintrag zu erstellen, der nicht in die Ressourcensammlung integriert ist, verwenden Sie Chef :: Log anstelle der Protokollressource.)

macports_package

Verwenden Sie die Ressource macports_package, um Pakete für die Mac OS X-Plattform zu verwalten.

Mdadm

Verwenden Sie die mdadmRessource zum Verwalten von RAID-Geräten in einer Linux-Umgebung mit dem Dienstprogramm mdadm. Der mdadm-Anbieter erstellt und stellt ein Array zusammen, erstellt jedoch nicht die Konfigurationsdatei, mit der das Array beim Neustart beibehalten wird.

Wenn die Konfigurationsdatei erforderlich ist, muss eine Vorlage mit dem richtigen Array-Layout angegeben und anschließend mithilfe des Mount-Anbieters ein Dateisystemtabelleneintrag (fstab) erstellt werden.

Montieren

Verwenden Sie die Mount-Ressource, um ein gemountetes Dateisystem zu verwalten.

Ohai

Verwenden Sie die ohaiRessource zum erneuten Laden der Ohai-Konfiguration auf einem Knoten. Auf diese Weise können Rezepte, die Systemattribute ändern (wie ein Rezept, das einen Benutzer hinzufügt), später während des Koch-Client-Laufs auf diese Attribute verweisen.

Paket

Verwenden Sie die packageRessource zum Verwalten von Paketen. Wenn das Paket aus einer lokalen Datei installiert wird (z. B. mit RubyGems, dpkg oder RPM Package Manager), muss die Datei mithilfe der Ressourcen remote_file oder cookbook_file zum Knoten hinzugefügt werden.

pacman_package

Verwenden Sie die pacman_package Ressource zum Verwalten von Paketen (mit pacman) auf der Arch Linux-Plattform.

Powershell_script

Verwenden Sie die powershell_scriptRessource zum Ausführen eines Skripts mit dem Windows PowerShell-Interpreter, ähnlich wie die skript- und skriptbasierten Ressourcen - bash, csh, perl, python und ruby ​​- verwendet werden. Das Powershell-Skript ist spezifisch für die Microsoft Windows-Plattform und den Windows PowerShell-Interpreter.

Python

Verwenden Sie die pythonRessource zum Ausführen von Skripten mit dem Python-Interpreter. Diese Ressource kann auch alle Aktionen und Eigenschaften verwenden, die der Ausführungsressource zur Verfügung stehen.

Befehle, die mit dieser Ressource ausgeführt werden, sind (von Natur aus) nicht idempotent, da sie normalerweise nur für die Umgebung gelten, in der sie ausgeführt werden. Verwenden Sie not_if und only_if, um diese Ressource vor Idempotenz zu schützen.

Starten Sie neu

Verwenden Sie die rebootRessource zum Neustart eines Knotens, ein notwendiger Schritt bei einigen Installationen auf bestimmten Plattformen. Diese Ressource wird für die Verwendung auf Microsoft Windows-, Mac OS X- und Linux-Plattformen unterstützt.

Registrierungsschlüssel

Verwenden Sie die registry_key Ressource zum Erstellen und Löschen von Registrierungsschlüsseln in Microsoft Windows.

remote_directory

Verwenden Sie die remote_directoryRessource zum schrittweisen Übertragen eines Verzeichnisses von einem Kochbuch auf einen Knoten. Das Verzeichnis, das aus dem Kochbuch kopiert wird, sollte sich unter COOKBOOK_NAME / files / default / REMOTE_DIRECTORY befinden.

Die Ressource remote_directory entspricht der Dateispezifität.

remote_file

Verwenden Sie die remote_fileRessource zum Übertragen einer Datei von einem Remotestandort mithilfe der Dateispezifität. Diese Ressource ähnelt der Dateiressource.

Route

Verwenden Sie die Routenressource, um die Systemroutingtabelle in einer Linux-Umgebung zu verwalten.

rpm_package

Verwenden Sie die rpm_package Ressource zum Verwalten von Paketen für die RPM Package Manager-Plattform.

Rubin

Verwenden Sie die rubyRessource zum Ausführen von Skripten mit dem Ruby-Interpreter. Diese Ressource kann auch alle Aktionen und Eigenschaften verwenden, die der Ausführungsressource zur Verfügung stehen.

Befehle, die mit dieser Ressource ausgeführt werden, sind (von Natur aus) nicht idempotent, da sie normalerweise nur für die Umgebung gelten, in der sie ausgeführt werden. Verwenden Sie not_if und only_if, um diese Ressource vor Idempotenz zu schützen.

ruby_block

Verwenden Sie die ruby_blockRessource zum Ausführen von Ruby-Code während eines Chef-Client-Laufs. Ruby-Code in der ruby_block-Ressource wird während der Konvergenz mit anderen Ressourcen ausgewertet, während Ruby-Code außerhalb einer ruby_block-Ressource beim Kompilieren des Rezepts vor anderen Ressourcen ausgewertet wird.

Skript

Verwenden Sie die Skriptressource, um Skripte mit einem bestimmten Interpreter wie Bash, csh, Perl, Python oder Ruby auszuführen. Diese Ressource kann auch alle Aktionen und Eigenschaften verwenden, die der Ausführungsressource zur Verfügung stehen.

Befehle, die mit dieser Ressource ausgeführt werden, sind (von Natur aus) nicht idempotent, da sie normalerweise nur für die Umgebung gelten, in der sie ausgeführt werden. Verwenden Sie not_if und only_if, um diese Ressource vor Idempotenz zu schützen.

Bedienung

Verwenden Sie die service Ressource zum Verwalten eines Dienstes.

smart_os_package

Verwenden Sie die smartos_package Ressource zum Verwalten von Paketen für die SmartOS-Plattform.

solaris_package

Das solaris_package Die Ressource wird zum Verwalten von Paketen für die Solaris-Plattform verwendet.

Subversion

Verwenden Sie die subversion Ressource zum Verwalten von Quellcodeverwaltungsressourcen, die in einem Subversion-Repository vorhanden sind.

Vorlage

Verwenden Sie die templateRessource zum Verwalten des Inhalts einer Datei mithilfe einer ERB-Vorlage (Embedded Ruby) durch Übertragen von Dateien aus einem Unterverzeichnis von COOKBOOK_NAME / templates / in einen angegebenen Pfad auf einem Host, auf dem der Chef-Client ausgeführt wird. Diese Ressource enthält Aktionen und Eigenschaften aus der Dateiressource. Vorlagendateien, die von der Vorlagenressource verwaltet werden, folgen denselben Dateispezifitätsregeln wie die Dateien remote_file und file.

Nutzer

Verwenden Sie die user Ressource zum Hinzufügen von Benutzern, Aktualisieren vorhandener Benutzer, Entfernen von Benutzern und Sperren / Entsperren von Benutzerkennwörtern.

windows_package

Verwenden Sie die windows_package Ressource zum Verwalten von MSI-Paketen (Microsoft Installer Package) für die Microsoft Windows-Plattform.

windows_service

Verwenden Sie die windows_service Ressource zum Verwalten eines Dienstes auf der Microsoft Windows-Plattform.

yum_package

Verwenden Sie die yum_packageRessource zum Installieren, Aktualisieren und Entfernen von Paketen mit Yum für die Red Hat- und CentOS-Plattformen. Die Ressource yum_package kann Daten für Pakete auflösen, ähnlich wie Yum es kann, wenn es über die Befehlszeile ausgeführt wird. Dies ermöglicht eine Vielzahl von Optionen für die Installation von Paketen, z. B. Mindestversionen, virtuelle Bereitstellungen und Bibliotheksnamen.

Lightweight resource provider (LWRP) bietet eine Option zum Erweitern der Liste der verfügbaren Ressourcen durch Erweitern der Funktionen und ermöglicht es dem Chef-Benutzer, benutzerdefinierte Ressourcen zu erstellen.

Durch das Erstellen benutzerdefinierter Ressourcen kann man einfach Kochbücher schreiben, da man mit Chef DSL angereicherte benutzerdefinierte Ressourcen besitzen kann, um den Rezeptcode ausdrucksvoller zu gestalten.

In der Chef-Community werden viele der benutzerdefinierten Ressourcen mithilfe von LWRPs implementiert. Es gibt viele Arbeitsbeispiele für LWRP wieiptables_rules und apt_repository.

Arbeitsmethode

Stellen Sie sicher, dass einer den Kochbuchnamen Testing_resource und eine Ausführungsliste des Knotens hat, der das Testbuch Testing_resource enthält.

Gebäude LWRP

Step 1 - Erstellen Sie eine benutzerdefinierte Ressource im Testing_resource-Kochbuch.

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 - Erstellen Sie einen Anbieter für Ressourcen im Tesing_resource-Kochbuch.

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 - Verwenden Sie eine neue Ressource, indem Sie das Standardrezept von Testing_resource bearbeiten.

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

Step 4 - Laden Sie das geänderte Kochbuch auf den Chef-Server hoch.

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

Step 5 - Führen Sie Chef-Client auf dem Knoten aus.

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 - Überprüfen Sie den Inhalt der generierten Datei.

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

Workflow-Skripte

LWRPs leben in Kochbüchern. Eine benutzerdefinierte Ressource befindet sich in den Kochbüchern und ist unter dem Namen des Kochbuchs verfügbar. Im Workflow definieren wir zuerst die Definitionen und übergeben dann die Attribute an die Ressourcen, die im Kochbuch verwendet werden sollen. Schließlich verwenden wir diese Aktionen und Attribute in unserem Rezept.

In Chef sind Blaupausen die Werkzeuge, um herauszufinden und genau aufzuzeichnen, was auf dem Server vorhanden ist. Blaupausen zeichnen alle erforderlichen Dinge auf, z. B. Direktoren, Pakete, Konfigurationsdateien usw. Blaupausen können Serverinformationen in verschiedenen Formaten aufteilen. Eines davon ist das Rezept des Küchenchefs. Dies hilft bei der Konfiguration eines eindeutigen Servers mit Chef.

Woring-Methode

Python und Git müssen auf dem Knoten installiert sein, auf dem die Blaupause ausgeführt werden soll.

Step 1 - Installieren Sie die Blaupause.

vipin@server:~$ pip install blueprint

Step 2 - Erstellen Sie eine Blaupause.

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 - Erstellen Sie ein Kochbuch aus der Blaupause.

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

Step 4 - Überprüfen Sie den Inhalt der generierten Datei.

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

Workflow-Skript

Blueprint ist ein Python-Paket, das alle relevanten Konfigurationsdaten des Servers ermittelt und in einem Git-Repo speichert. Jede Blaupause hat einen eigenen Namen.

Man kann den Entwurf bitten, den Inhalt seines Git-Repos in verschiedenen Formanten anzuzeigen.

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

Blaupausen Befehle anzeigen

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

Der vorhergehende Befehl zeigt alle Arten von installierten Paketen. Andere show-Befehle lauten wie folgt:

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

In Chef sind das Erstellen von Konfigurationsdateien und das Verschieben von Paketen die Schlüsselkomponenten. Es gibt mehrere Möglichkeiten, wie Chef das gleiche verwaltet. Es gibt mehrere Möglichkeiten, wie Chef beim Umgang mit Dateien und Softwarepaketen unterstützt.

Installieren von Paketen aus Repo von Drittanbietern

Step 1 - Bearbeiten Sie das Standardrezept des Kochbuchs.

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 - Bearbeiten Sie die Metadaten, um die Abhängigkeit vom passenden Kochbuch zu erhöhen.

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

Step 3 - Laden Sie das geänderte Kochbuch auf den Chef-Server hoch.

Step 4 - Überprüfen Sie, ob das Paket, das Sie installieren möchten, noch nicht installiert ist.

Step 5 - Überprüfen Sie das Standard-Repo.

Step 6 - Führen Sie Chef-Client auf dem Knoten aus.

Step 7 - Überprüfen Sie, ob das erforderliche Paket installiert ist.

Software von der Quelle installieren

Wenn Sie eine Software installieren müssen, die für eine bestimmte Plattform nicht als Paket verfügbar ist, müssen Sie sie selbst kompilieren. In Chef können wir dies mithilfe der Skriptressource tun.

Step 1 - Bearbeiten Sie das Standardrezept.

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 - Laden Sie das geänderte Kochbuch auf den Chef-Server hoch.

Step 3 - Führen Sie den Chef-Client auf dem Knoten aus.

Step 4 - Überprüfen Sie, ob der Nginx installiert ist.

Community-Kochbücher ähneln jedem anderen Kochbuch. Der einzige Grund, warum es als Community-Kochbuch bezeichnet wird, ist, dass jeder, der Kochbücher schreiben kann, dieser Community beitreten und seine Kochbücher auf den zentralen Hub hochladen kann. Diese Kochbücher sind kostenlos erhältlich und können von jedem heruntergeladen und verwendet werden. Um diese Community-Kochbücher verwenden zu können, müssen sie heruntergeladen, gemäß den Anforderungen geändert und auf den jeweiligen Chef-Server hochgeladen werden.

Das Messer muss auf dem System konfiguriert sein, damit die Kochbücher aktualisiert, hochgeladen und heruntergeladen werden können. Interagieren Sie mit Kochbüchern mithilfe der Messerkochbuchbefehle. Mit dem Messerkochbuch können Sie Kochbücher erstellen, löschen, anzeigen, auflisten, herunterladen und hochladen. Weitere Informationen finden Sie in der Dokumentation zu den Messerkochbuchbefehlen in Kapitel 7.

Es folgt der Link zu Community-Kochbüchern: https://supermarket.chef.io/cookbooksdirectory