linux_provision 0.9.3 → 0.9.4

data/presentation/virtualization/02-provision/slides.md

@@ -0,0 +1,400 @@
+
+!SLIDE content transition=cover
+
+# Provisioning
+
+>
+
+![provisioning](../images/provisioning.jpg)
+
+
+
+!SLIDE title-and-content incremental transition=cover
+
+# Use Cases
+
+* Provide **clean clone of production environment**. You can guarantee that your staging server is a exact clone of
+your production server.
+
+* **Team of developers working along the globe and on different platforms**. The idea is to do development against
+unified, easy to replicate virtual platform with same characteristics for all developers.
+
+* **Configure new workstation for new employee**, e.g. macbook configuration (rvm, ruby, mysql, postgesql, skype, iterm2 etc.)
+
+
+
+!SLIDE title-and-content incremental transition=zoom
+
+# Available options for provisioning
+
+* Create simple shell script
+* Use chef gem
+* Use puppet gem (out of scope)
+* Provisioning from Github: [Boxen](http://boxen.github.com/) - tool for automating and managing Macs with Puppet
+
+
+
+!SLIDE content transition=cover
+
+# Chef
+
+>
+
+![chef](chef.jpg)
+
+
+
+!SLIDE title-and-content transition=cover incremental
+
+# Chef - what is it?
+
+> Chef is like unit tests for your servers
+
+>[Ezra Zygmuntowicz](http://www.linkedin.com/in/ezraz)
+
+
+* It is **domain specific language** based on ruby.
+
+* You can write **installation scripts** that will install all required for your platform packages (like homebrew or macport).
+
+* Could be executed **locally** or on **remote** server.
+
+
+
+!SLIDE title-and-content incremental transition=cover
+
+# Types of Chef components
+
+* **Chef Server** - used to distribute cookbooks, manage and authenticate nodes and query
+infrastructure information on multiple nodes.
+* **Chef Client** - command line tool for interacting with Chef Server.
+* **Chef Solo** - you can run cookbooks in the absence of a Chef Server on single node.
+You need to have cookbooks somewhere. <span style="color:red">Only Chef Solo will be used in this presentation</span>.
+
+
+
+!SLIDE title-and-content transition=cover
+
+# Common conceps of Chef
+
+* **Node** - A host where the Chef client will be executed.
+
+* **Recipe** - ruby program with code to install or configure software
+(install webserver or database, create database user etc.).
+
+```ruby
+# cookbooks/application/default.rb
+
+include_recipe "rvm" # include another recipe
+
+package "rvm" # include OS package
+
+bash "ls -al" # run OS command
+```
+
+
+
+!SLIDE title-and-content transition=cover
+
+# Common concepts of Chef (continued)
+
+* **Cookbook** - a collection of recipes (e.g. db cookbook could handle common interface for
+installing/configuring mysql and postgresql).
+
+```
+  -cookbooks
+    -application
+      -attributes
+        default.rb
+      -recipes
+        default.rb
+        my_postgres.rb
+        my_mysql.rb
+      -templates
+        Gemfile.erb
+        mysql_database.yml.erb
+```
+
+
+
+!SLIDE title-and-content transition=cover
+
+# Common concepts of Chef (continued)
+
+* **Attribute** - default values to be used by cookbook in order to configure it (e.g. required
+version, service port or user name/password etc.). They can be redefined when you configure recipe.
+
+* **Data Bags** - collection of properties that can be used together.
+
+* **Metadata** - describes the recipes, dependencies, supported platforms, etc.
+
+
+
+!SLIDE title-and-content transition=cover
+
+# Common concepts of Chef (continued)
+
+* **Resource** - it could be file, directory, package, service etc.
+
+```ruby
+  directory "/var/cache/local/preseeding" do
+    owner "root"
+    group node['mysql']['root_group']
+    mode 0755
+    recursive true
+  end
+  service "mysql" do
+    action :start
+  end
+  dmg_package "GitOSX-Installer" do
+    type "pkg"
+    action :install
+  end
+  cron "noop" do
+    hour "5"
+    minute "0"
+    command "/bin/true"
+  end
+```
+
+
+!SLIDE title-and-content transition=cover
+
+# Common concepts of Chef (continued)
+
+* **Template** - powered by ERB and used for generation configuration files.
+
+```ruby
+template "#{node[:rails][:app_root]}/Gemfile" do
+  source "Gemfile.erb"
+  mode "0666"
+  owner node[:rails][:user]
+  group node[:rails][:group]
+  variables({ :db_gem => "mysql" })
+  not_if { `ls #{node[:rails][:app_root]}`.include?("Gemfile") }
+end
+```
+
+* **Role** - reusable configuration for multiple nodes (mac user role, web role, database role, etc).
+
+* **Run List** - list of recipes and roles to run.
+
+
+
+!SLIDE title-and-content transition=cover
+
+# Running
+
+* You create **recipes run list** in order to run provision.
+
+```yml
+{
+  "run_list": [ "recipe[application]" ]
+}
+```
+
+* Chef runs a bunch of recipes to set up your server.
+
+* You can run it with vagrant:
+
+```bash
+vagrant provision
+vagrant reload
+vagrant up
+```
+
+* or with chef-solo:
+
+```bash
+chef-solo -c your-solo-config-location.rb
+          -j your-solo-node-location.json
+```
+
+
+!SLIDE title-and-content transition=cover
+
+# Example of configuration file
+
+```ruby
+project_root = File.dirname(File.expand_path(__FILE__))
+
+cookbook_path [File.join(project_root, "..", "cookbooks"),
+               File.join(project_root, "..", "vendored_cookbooks")]
+
+#json_attribs File.join(project_root, "..", "nodes",
+#   "vagrant-node.json")
+```
+
+
+!SLIDE title-and-content transition=cover
+
+# Example of vagrant-node.json file
+
+```json
+{
+  "run_list": [ "recipe[application]" ],
+
+  "application": { "app_name": "triton" },
+
+  "rvm": {"ruby": {"version": "1.9.3",
+                   "implementation": "ruby",
+                   "patch_level": "p392"}},
+
+  "postgresql": { "username": "postgres", "password": "postgres"},
+
+  "mysql": { "server_debian_password": "root",
+             "server_root_password": "root",
+             "server_repl_password": "root"}
+}
+```
+
+
+
+!SLIDE title-and-content transition=cover
+
+# Chef-Solo: Standalone Installation
+
+* If you want to use chef apart from vagrant, you have to install chef gem:
+
+```bash
+gem install chef
+```
+
+* and then use it:
+
+```bash
+ssh user@your_server
+cd
+sudo chef-solo -c /vagrant/config/solo.rb -c /vagrant/nodes/node.rb
+```
+
+* <div style="color:red">Important: do it from user home.</div>
+
+
+!SLIDE title-and-content transition=cover
+
+# Common recipes
+
+* Public cookbooks are located at [opscode community home](http://community.opscode.com/cookbooks)
+
+* For easy manipulation with common recipes, install **librarian-chef** gem:
+
+```bash
+gem install librarian-chef
+```
+
+* Initialize librarian-chef. New **Cheffile** file will be created:
+
+```bash
+librarian-chef init
+```
+
+* Install cookbooks defined in Cheffile:
+
+```bash
+librarian-chef install --path vendored_cookbooks
+```
+
+* We keep them separately from our cookbooks. Our cookbooks are located in **cookbooks** folder.
+
+
+
+!SLIDE title-and-content transition=cover
+
+# Example of Cheffile
+
+```ruby
+site 'http://community.opscode.com/api/v1'
+
+cookbook 'apt'
+cookbook 'git'
+
+cookbook 'mysql'
+cookbook 'postgresql'
+```
+
+* Other useful commands:
+
+```bash
+librarian-chef outdated
+librarian-chef update
+```
+
+
+
+!SLIDE title-and-content transition=cover
+
+# Tip 1: Skipping consecutive runs
+
+* If you run it several times, Chef can skip all consecutive runs, thanks to **not_if** method call:
+
+```ruby
+app_user = 'app_user'
+postgres_user = 'postgres'
+db_schema = 'myapp_dev'
+
+bash "Creating postgres db user" do
+  user "postgres"
+
+  code <<-CODE
+    psql -c "CREATE USER #{app_user} WITH PASSWORD '#{app_user}'"
+  CODE
+
+  not_if { `sudo sudo -u #{postgres_user} psql -c '\\l'`.
+    include?(db_schema) }
+end
+```
+
+
+
+!SLIDE title-and-content transition=cover
+
+# Tip 2: Support for multiple platforms
+
+* You can to different actions for different patforms if you want:
+
+```ruby
+# cookbooks/some_recipe/recipes/default.rb
+
+case node[:platform]
+  when "ubuntu"
+    package "package_for_ubuntu"
+  when "centos"
+    package "package_for_centos"
+  when "mac_os_x"
+    package "package_for_mac_os_x"
+end
+```
+
+
+
+!SLIDE title-and-content transition=cover
+
+# Tip 3: Integration with Capistrano
+
+* Capistrano **Capfile** script
+
+```ruby
+set :application, "vagrant"
+set :host, "22.22.22.22"
+set :user, "vagrant"
+set :password, "vagrant"
+role :vagrant, host
+
+namespace :vagrant do
+
+  desc "Execute chef run_list"
+  task :run_list, :roles => :vagrant do
+    cmd = "/opt/vagrant_ruby/bin/chef-solo -c /vagrant/config/solo.rb
+    -j /vagrant/nodes/vagrant-node.json"
+
+    run %[sudo #{cmd}]
+  end
+end
+```
+
+* Now you can run this task:
+
+```bash
+  cap vagrant:run_list
+```

data/presentation/virtualization/03-docker/slides.md

@@ -0,0 +1,208 @@
+!SLIDE
+
+## What is it?
+
+* "open source project to pack, ship and run any application as a lightweight container”. 
+ 
+* it works much like a virtual machine, wraps everything (filesystem, process management, environment variables, etc.) 
+into a container. 
+
+* Unlike a VM, it uses LXC (Linux kernel container) instead of a hypervisor. 
+
+* LXC doesn’t have its own kernel, but shares the Linux kernel with the host and other containers instead. Based on LXC, 
+Docker is so lightweight, that it introduces almost no performance drawback while running the application.
+
+* provides a smart way to manage your images. Through Dockerfile and its caching mechanism, one can easily redeploy 
+an updated image without transferring large amounts of data.
+
+
+## When it make sense to use?
+
+* With VM You have to upload the whole new image even if you just made a small update. With Docker
+you don’t have to upload the whole image again. Docker is based on AuFS, which tracks the diff of the whole filesystem.
+
+* There is a significant performance loss. With Docker The performance loss is ignorable since it runs on the host kernel.
+
+* Your probably run your application on a VPS, which is already a virtualized environment. 
+You can’t run a VM on top of another. You can run Docker on a VM because Docker is not a VM
+
+## How it works?
+
+* Docker needs to be run with root privelege.
+
+Docker DOESN’T write into the image. Instead, it creates a layer with each Dockerfile line on top of the existing image, 
+which contains the modifications you made to the filesystem. Migrating from a previous state of filesystem to 
+a recent one is applying one or more layers on top of the old image, just like patching files.
+
+When a container is stopped, you can commit it. Committing a container is creating an additional layer on top 
+of the base image. As expected, the official ubuntu image is also made up of several layers.
+
+## What is Boot2Docker?
+
+Boot2Docker is a lightweight Linux distribution made specifically to run Docker containers. It runs 
+completely from RAM, is a small ~24MB download and boots in ~5s (YMMV).
+
+Installation instructions for OS X and Windows available on the Docker documentation site.
+
+## How to use Boot2Docker
+
+The boot2docker managment tool leverages VirtualBox's VBoxManage to initialise, start, stop and delete 
+the VM right from the command line.
+
+# Initialize
+
+$ boot2docker init
+
+# Start VM
+
+$ boot2docker up
+
+# Upgrade the Boot2docker VM image
+
+$ boot2docker stop
+$ boot2docker download
+$ boot2docker up
+
+If your Boot2Docker virtual machine was created prior to 0.11.1-pre1, its best to delete - 
+boot2docker delete and then boot2docker init to create a new VM.
+
+The main changes are to add a /var/lib/boot2docker/userdata.tar file that is un-tarred 
+into the /home/docker directory on boot. This file contains a .ssh/authorized_keys and .ssh/authorized_keys2 
+files containing a public sshkey.
+
+## Installation
+
+* Download and install VirtualBox for OSX
+
+https://www.virtualbox.org/wiki/Downloads
+
+* Install boot2docker and docker via homebrew:
+
+```bash
+brew install boot2docker
+```
+Docker will be installed as an dependency.
+
+Initialize boot2docker virtual machine:
+
+```bash
+boot2docker init
+```
+
+Update .bash_profile file:
+
+
+```bash
+export DOCKER_HOST=tcp://192.168.59.103:2375
+```
+
+Start the docker daemon:
+
+```bash
+boot2docker up
+```
+
+or down:
+
+```bash
+boot2docker down
+```
+
+ssh it:
+
+```bash
+boot2docker ssh
+
+# User: docker
+# Pwd:  tcuser
+```
+
+Download the small base image named busybox:
+
+```bash
+docker pull busybox
+docker pull ubuntu
+docker pull centos
+```
+
+Run and test as separate command:
+
+```bash
+docker run ubuntu /bin/echo hello world
+```
+
+and interactively:
+
+
+```bash
+docker run -t -i ubuntu /bin/bash
+```
+
+```bash
+docker stop $(docker ps -a -q)
+docker rm $(docker ps -a -q)
+
+# Build containers from Dockerfiles
+docker build -t postgres docker/postgres
+docker build -t demo demo
+
+# Run and link the containers
+docker run -d -p 5432:5432 --name postgres postgres:latest
+
+docker run --rm -p 42222:22 -p 9292:9292 -e POSTGRESQL_HOST='192.168.59.103' --name demo demo:latest /bin/bash -l -c "rackup"
+
+--link postgres:db
+
+docker run -d -p 9292:9292 --name demo demo:latest /bin/bash -l -c "rackup"
+``` 
+ 
+```bash
+boot2docker ip # 192.168.59.103
+
+open http://192.168.59.103
+
+
+docker run --rm ubuntu env
+
+docker port demo 22
+
+ssh root@localhost -p 49153
+
+ VBoxManage modifyvm "boot2docker-vm" --natpf1 "containerssh,tcp,,42222,,42222"
+ 
+```
+
+
+
+-d means run in the background
+
+--name xyz gives the container the friendly name xyz which we can use to refer to it later when we want to 
+stop it or link it to another container
+
+-p 3000:3000 makes port 3000 from the container available as port 3000 on the host (the Virtualbox VM). Since we have Vagrant configured to forward port 3000 of the VM to your local machine 3000, you can access this container on port 3000 on your development machine as you would the normal Rails dev server (e.g. http://localhost:3000).
+
+--link postgres:db establishes a link between the container you're starting (your Rails app) and the 
+Postgres container you started previously. This is in the format name:alias and will make ports exposed by the 
+Postgres container available to the Rails container.
+
+
+
+!SLIDE
+
+## Links
+
+* Installing Docker on Mac OS X https://docs.docker.com/installation/mac/
+* [Docker sources project = *https://github.com/dotcloud/docker*](https://github.com/dotcloud/docker)
+* [Deploy Rails Applications Using Docker - *http://steveltn.me/blog/2014/03/15/deploy-rails-applications-using-docker*](http://steveltn.me/blog/2014/03/15/deploy-rails-applications-using-docker)
+* [How to Skip Bundle Install When Deploying a Rails App to Docker if the Gemfile Hasn’t Changed - *http://ilikestuffblog.com/2014/01/06/how-to-skip-bundle-install-when-deploying-a-rails-app-to-docker*](http://ilikestuffblog.com/2014/01/06/how-to-skip-bundle-install-when-deploying-a-rails-app-to-docker)
+
+
+http://www.talkingquickly.co.uk/2014/06/rails-development-environment-with-vagrant-and-docker
+https://github.com/TalkingQuickly/docker_rails_dev_env/
+https://coreos.com/docs/launching-containers/building/getting-started-with-docker
+http://docs.docker.io/installation/binaries/#dockergroup
+http://blog.gemnasium.com/post/65599561888/rails-meets-docker
+https://github.com/gemnasium/rails-meets-docker
+https://medium.com/@flawless_retard/a-osx-vagrant-docker-ruby-on-rails-setup-117daf4ef0a5
+Docker Cheat Sheet - https://gist.github.com/wsargent/7049221
+