W jaki sposób kpisz z usług/zależności zależnych od OpsWorks podczas pracy lokalnie z kuchnią i szefem kuchni?

Question

Piszę opakowania szefa kuchni wokół niektórych książek kucharskich OpsWorks. Używam Berkshelf do sklonowania książek kucharskich OpsWorks z ich repozytorium github.

To mój Berksfile:

source 'https://supermarket.getchef.com' 

metadata 

def opsworks_cookbook(name) 
    cookbook name, github: 'aws/opsworks-cookbooks', branch: 'release-chef-11.10', rel: name 
end 

%w(dependencies scm_helper mod_php5_apache2 ssh_users opsworks_agent_monit 
    opsworks_java gem_support opsworks_commons opsworks_initial_setup 
    opsworks_nodejs opsworks_aws_flow_ruby 
    deploy mysql memcached).each do |cb| 
    opsworks_cookbook cb 
end 

Moja metadata.rb:

depends 'deploy' 
depends 'mysql' 
depends 'memcached' 

Problem jest, gdy próbuję zastąpić atrybuty, które zależą od klucza w node hash opsworks, ja Pobierz:

NoMethodError 
------------- 
undefined method `[]=' for nil:NilClass 

OpsWorks ma całą garść zależności od receptury te, które tworzą te klucze i wykonują wiele ich konfiguracji. Chciałbym znaleźć sposób, aby albo skorzystać z tych usług i uruchomić je przeciwko moim instancjom kuchennym, albo wyśmiewać je w taki sposób, że mogę przetestować moje przepisy.

Czy istnieje sposób, aby to zrobić?

Answer 1

Będziesz musiał to zrobić ręcznie. Możesz dodać dowolne atrybuty do swojego .kitchen.yml, po prostu przejdź na maszynę OpsWorks i zarejestruj wymagane wartości i albo użyj ich bezpośrednio, albo dostosuj je do wykonalnych danych testowych.

Answer 2

Gorąco polecam sprawdzić Mike Greiling na blogu Simplify OpsWorks Development With Packer i jego GitHub repo opsworks-vmktóre pomogą Ci wyśmiewać cała opsworks stack w tym instalacji agenta opsworks więc można również testy aplikacji wdrożyć recepty, wiele warstw, wiele wystąpień w tym samym czasie, itp.. Jest niesamowicie imponujący.

Skrócona na Ubuntu 14.04

UWAGA: to nie może być wykonane z maszyny wirtualnej VirtualBox bo ubuntu nie obsługuje zagnieżdżone wirtualizacji maszyn 64-bitowych.

1. Instalacja ChefDK
   1. mkdir /tmp/packages && cd /tmp/packages
   2. wget https://opscode-omnibus-packages.s3.amazonaws.com/ubuntu/12.04/x86_64/chefdk_0.8.1-1_amd64.deb
   3. sudo dpkg -i chefdk_0.8.0-1_amd64.deb
   4. cd /opt/chefdk/
   5. chef verify
   6. which ruby
   7. echo 'eval "$(chef shell-init bash)"' >> ~/.bash_profile && source ~/.bash_profile
2. Instalacja VirtualBox
   1. echo 'deb http://download.virtualbox.org/virtualbox/debian vivid contrib' > /etc/apt/sources.list.d/virtualbox.list
   2. wget -q https://www.virtualbox.org/download/oracle_vbox.asc -O- | sudo apt-key add -
   3. sudo apt-get update -qqy
   4. sudo apt-get install virtualbox-5.0 dkms
3. Instalacja Vagrant
   1. cd /tmp/packages
   2. wget https://dl.bintray.com/mitchellh/vagrant/vagrant_1.7.4_x86_64.deb
   3. sudo dpkg -i vagrant_1.7.4_x86_64.deb
   4. vagrant plugin install vagrant-berkshelf
   5. vagrant plugin install vagrant-omnibus
   6. vagrant plugin list
4. Instalacja Packer
   1. mkdir /opt/packer && cd /opt/packer
   2. wget https://dl.bintray.com/mitchellh/packer/packer_0.8.6_linux_amd64.zip
   3. unzip packer_0.8.6_linux_amd64.zip
   4. echo 'PATH=$PATH:/opt/packer' >> ~/.bash_profile && source ~/.bash_profile
5. Budowa Mike Greiling za opsworks-vm VirtualBox obraz używając Packer
   1. mkdir ~/packer && cd ~/packer
   2. git clone https://github.com/pixelcog/opsworks-vm.git
   3. cd opsworks-vm
   4. rake build install
   5. To zainstaluje nowy VirtualBox VM ~/.vagrant.d/pojemnika/ubuntu1404-opsworks/

MOCK jedno wystąpienie opsworks utworzyć nowy Vagrantfile tak:

Vagrant.configure("2") do |config| 
    config.vm.box = "ubuntu1404-opsworks" 
    config.vm.provision :opsworks, type: 'shell', args: 'path/to/dna.json' 
end 

Ścieżka dna.json plik jest ustawiona w stosunku do Vagrantfile oraz powinna zawierać dowolne dane JSON, które chcesz przesłać do OpsWorks Chef.

Na przykład:

{ 
    "deploy": { 
    "my-app": { 
     "application_type": "php", 
     "scm": { 
     "scm_type": "git", 
     "repository": "path/to/my-app" 
     } 
    } 
    }, 
    "opsworks_custom_cookbooks": { 
    "enabled": true, 
    "scm": { 
     "repository": "path/to/my-cookbooks" 
    }, 
    "recipes": [ 
     "recipe[opsworks_initial_setup]", 
     "recipe[dependencies]", 
     "recipe[mod_php5_apache2]", 
     "recipe[deploy::default]", 
     "recipe[deploy::php]", 
     "recipe[my_custom_cookbook::configure]" 
    ] 
    } 
} 

drwić wiele opsworks instancje i zawierać warstwy zobaczyć jego AWS OpsWorks "Getting Started" Example który obejmuje poniżej stack.json.

Vagrantfile (dla wielu wystąpień)

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

    config.vm.box = "ubuntu1404-opsworks" 

    # Create the php-app layer 
    config.vm.define "app" do |layer| 

    layer.vm.provision "opsworks", type:"shell", args:[ 
     'ops/dna/stack.json', 
     'ops/dna/php-app.json' 
    ] 

    # Forward port 80 so we can see our work 
    layer.vm.network "forwarded_port", guest: 80, host: 8080 
    layer.vm.network "private_network", ip: "10.10.10.10" 
    end 

    # Create the db-master layer 
    config.vm.define "db" do |layer| 

    layer.vm.provision "opsworks", type:"shell", args:[ 
     'ops/dna/stack.json', 
     'ops/dna/db-master.json' 
    ] 

    layer.vm.network "private_network", ip: "10.10.10.20" 
    end 
end 

stack.json

{ 
    "opsworks": { 
    "layers": { 
     "php-app": { 
     "instances": { 
      "php-app1": {"private-ip": "10.10.10.10"} 
     } 
     }, 
     "db-master": { 
     "instances": { 
      "db-master1": {"private-ip": "10.10.10.20"} 
     } 
     } 
    } 
    }, 
    "deploy": { 
    "simple-php": { 
     "application_type": "php", 
     "document_root": "web", 
     "scm": { 
     "scm_type": "git", 
     "repository": "dev/simple-php" 
     }, 
     "memcached": {}, 
     "database": { 
     "host": "10.10.10.20", 
     "database": "simple-php", 
     "username": "root", 
     "password": "correcthorsebatterystaple", 
     "reconnect": true 
     } 
    } 
    }, 
    "mysql": { 
    "server_root_password": "correcthorsebatterystaple", 
    "tunable": {"innodb_buffer_pool_size": "256M"} 
    }, 
    "opsworks_custom_cookbooks": { 
    "enabled": true, 
    "scm": { 
     "repository": "ops/cookbooks" 
    } 
    } 
} 

Dla tych, którzy nie znają włóczęgi po prostu zrobić vagrant up aby uruchomić instancję (y). Następnie możesz zmodyfikować swoją książkę kucharską lokalnie, a wszelkie zmiany można zastosować, ponownie uruchamiając szefa kuchni w stosunku do istniejących instancji za pomocą vagrant provision. Możesz zrobić vagrant destroy i vagrant up, aby rozpocząć od zera.