Ich habe Chef-Umgebung konfiguriert und ich bin in der Lage, meine Anwendung mit capistrano zu implementieren. Jetzt möchte ich zu meinem Kochcapistrano behandeln, um meine Anwendungen bereitzustellen. Wie kann es gemacht werden?Wie man Chef mit Capistrano für die Bereitstellung verbindet
Sie könnten diese Foodfightshow Episode über Application Deployment ansehen.
Sie können z.B. Legen Sie die Konfigurationsdateien (z. B. die Datenbankanmeldeinformationen) mit Chef auf den Server, und schieben Sie den Quellcode mit Capistrano.
Sie können nicht. Zumindest wird es nicht sehr einfach sein.
Chef ist ein Pull-System - der Client ruft Informationen vom Chef-Server ab und ergreift Maßnahmen.
Capistrano ist ein Push-System - Sie sagen ihm, sich in den Server einzuloggen und dort Aufgaben auszuführen.
Der einzige Weg, den ich für Sie sehe, um sie zu integrieren, wäre, Capistrano lokal auf jeder Maschine laufen zu lassen, aber ich sehe keinen Grund dafür.
Chef Bereitstellungsressource kann wahrscheinlich alles tun, was Sie brauchen, ohne Capistrano integriert zu haben. Wenn Sie Ihre Bereitstellungen unabhängig vom Ausführen des Chef-Clients weiterhin auf die Server übertragen möchten, sollten Sie die Bereitstellung nicht über Chef durchführen und Ihr aktuelles System beibehalten.
Wenn Sie eine kontinuierliche Lieferung wünschen, schließen Sie Ihre Capistrano-Skripts an Ihren CI-Server an und führen Sie sie am Ende Ihrer Pipeline aus.
Der Podcast von @ StephenKing ist eine großartige Informationsquelle zu diesem Thema.
Ich mache das Gegenteil, dh. Stellen Sie meine Kochrezepte über Capistrano bereit. Ich empfehle es.
#config/deploy.rb
...
before 'bundle:install', "provision:default", "deploy:config_db_yml_symlink"
...
Dadurch wird der Koch Config für einen Server nach, bevor Bündel installieren, führen die, weil viele Edelsteine wichtig ist, verlassen sich auf Pakete an das Betriebssystem installiert wird.
#config/deploy/provision.rb
Capistrano::Configuration.instance(:must_exist).load do
namespace :provision do
task :default do
provision.setup
provision.web
provision.db
provision.db_slave
end
task :setup, once: true do
provision.get_environment_variables
provision.update_cookbooks
end
task :db, :roles => :db do
next if find_servers_for_task(current_task).empty?
if rails_env == 'staging'
run %{cd #{release_path}/provision; sudo chef-solo -c solo.rb -j db.json -l debug}
else
run %{cd #{release_path}/provision; sudo chef-solo -c solo.rb -j db_master.json -l debug}
end
end
task :db_slave, :roles => :db_slave do
next if find_servers_for_task(current_task).empty?
run %{cd #{release_path}/provision; sudo chef-solo -c solo.rb -j db_slave.json -l debug}
end
task :web, :roles => :web do
next if find_servers_for_task(current_task).empty?
run %{cd #{release_path}/provision; sudo chef-solo -c solo.rb -j web.json -l debug}
end
task :get_environment_variables do
run "if [ -d ~/.config ]; then " +
"cd ~/.config && git fetch && git reset origin/master --hard; " +
"else git clone [email protected]:mycompany/config.git .config; fi"
run "sudo cp ~/.config/secureshare/#{rails_env}/environment /etc/environment"
end
task :update_cookbooks do
run "if [ -d /u/chef ]; then " +
"cd /u/chef && git fetch && git reset origin/master --hard; " +
"else git clone [email protected]:mycompany/chef.git /u/chef; fi"
end
end
namespace :deploy do
task :setup, :except => { :no_release => true } do
dirs = [deploy_to, releases_path, shared_path]
dirs += shared_children.map { |d| File.join(shared_path, d.split('/').last) }
dirs += [File.join(shared_path, 'sockets')]
run "#{try_sudo} mkdir -p #{dirs.join(' ')}"
run "#{try_sudo} chmod g+w #{dirs.join(' ')}" if fetch(:group_writable, true)
run "#{try_sudo} chown -R ubuntu:ubuntu #{dirs.join(' ')}" if fetch(:group_writable, true)
end
task :config_db_yml_symlink do
run "ln -s #{shared_path}/database.yml #{release_path}/config/database.yml"
end
end
end
Ich habe einen Ordner in meinem Projekt mit dem Namen Bestimmung, die Definition von Koch Rollen zu handhaben, wenn die Rezepte in einem anderen Repository sind.
#provision/solo.rb
root = File.absolute_path(File.dirname(__FILE__))
cookbook_path '/u/chef'
role_path root + "/roles"
log_level :debug
log_location STDOUT
Knoten werden im Projekt
definiert#provision/db_slave.json
{
"run_list": ["role[db_slave]"]
}
Und Rollen
#provision/roles/db_slave.rb
name "db_slave"
description 'A postgresql slave.'
run_list(["recipe[base]", "recipe[postgresql::slave]", "recipe[rails]","recipe[papertrail]", "recipe[fail2ban]"])
override_attributes(
'kernel' => {
'shmmax' => ENV['KERNEL_SHMMAX'],
'shmall' => ENV['KERNEL_SHMALL'],
'msgmax' => ENV['KERNEL_MSGMAX'],
'msgmnb' => ENV['KERNEL_MSGMNB']
},
'postgresql' => {
'user' => ENV['PG_USER'],
'password' => ENV['PG_PASSWORD'],
'database' => ENV['PG_DATABASE'],
'master_host' => ENV['PG_HOST']
},
'app_dir' => ENV['APP_DIR'],
'papertrail' => {
'port' => ENV['PAPERTRAIL_PORT'],
'log_files' => [
"#{ENV['APP_DIR']}/shared/log/*.log",
"/var/log/*.log",
"/var/log/syslog",
"/var/log/upstart/*.log",
"/var/log/postgresql/*.log"
]
},
'new_relic' => {
'key' => ENV['NEW_RELIC_LICENSE_KEY']
})
Alle, ohne sich in der App keine sensiblen Informationen zu halten. Ich verwende auch capistrano-ec2group, um Server mithilfe von EC2-Sicherheitsgruppen zu Rollen zuzuordnen.
group :myapp_web, :web
group :myapp_web, :app
group :myapp_db, :db, :primary=>true
group :myapp_db_slave, :db_slave
Also im Grunde halten Sie Ihre Koch-Rezepte in einem Repo, die Umgebungsvariablen in einem anderen Repo, und Ihre Anwendung in einem anderen Repo - und verwenden Capistrano zu beiden Bereitstellung Server und Ihre App bereitstellen.
Sie können Ihre Kochrezepte auch in Ihrem Anwendungsrepo aufbewahren, aber dies verhindert die Wiederverwendung zwischen Projekten. Der Schlüssel ist, alles, was sich ändert, in Umgebungsvariablen zu setzen und sie getrennt von der App und den Rezepten zu speichern.
Wenn diese richtig konfiguriert ist, auf neue Server hinzufügen, müssen Sie einfach ein Spin up in EC2, gelten die Sicherheitsgruppe gewünscht und dann
cap deploy