mokevnin/workshop-devops-nginx repository overview

⁠Build From Scratch

1. File Structure

   project_name/ ansible/ services/ terraform/ .gitignore

2. Create rails project using docker

   cd project_name docker run -v pwd/services:/services mokevnin/rails rails new /services/app --skip-bundle --database=postgresql --skip-git --skip-coffee

3. Add ./services/app/.gitignore

   log vendor

4. Commit project to bitbucket

5. Setup docker composer

• Add ./services/app/Dockerfile.development

  • From ruby
  • Configure bundler and gem for storing gems to vendor

• Create project_name/docker-composer.yml with app services

• Add ./services/app/.dockerignore

  vendor tmp log

1. Add project_name/make-app.mk and include it to Makefile.

   app: docker-compose up

   app-build: docker-compose build

   app-bash: docker-compose run app bash

2. Install deps

   $ make app-bash bundle install

3. Run make app and check that site is working.

4. Add db

• Add db service to project_name/docker-composer.yml

  db: image: postgres environment: POSTGRES_USER: app

• Update ./services/app/config/database.yml

  • Set host to db
  • Set user to app

1. Add some logic

   $ make app-bash bin/rails generate scaffold Post title body:text bin/rails active_storage:install bin/rails db:migrate

2. Run tests

   $ make app-bash bin/rails db:test:prepare bin/rails test

3. Run app and open page /posts

4. Add make setup

   app-setup: app-build docker-compose run app bin/setup

   app-build: docker-compose build

5. Checkpoint

• Commit everything

• Remove project

• Clone project

• Run make app-setup app

• Open site and check it on pages / and /posts

• https://docs.docker.com/docker-cloud/builds/automated-testing/⁠

1. Create Ansible project structure

• Add ansible/group_vars/all/vars.yml

• Add ansible/group_vars/all/vault.yml

• Add ansible/development/group_vars/all/vars.yml

• Add ansible/development/group_vars/all/vault.yml

1. Add ansible/development/inventory

   localhost ansible_connection=local

2. Create playbook ansible/development.yml which generate project_name/.env from template ansible/templates/environment.j2

3. Create development-setup-env and run it (for check)

   development-setup-env: ansible-playbook ansible/development.yml -i ansible/development -vv

4. Add development-setup-env as deps for app-setup

   app-setup: development-setup-env app-build docker-compose run app bin/setup

5. Add project_name/.env to docker-composer.yml

   app: env_file: ".env"

6. Setup db username by env for docker-composer.yml and database.yml

• Create apropriate variables ansible/development/group_vars/all/vars.yml
• https://docs.docker.com/compose/environment-variables/#the-env-file⁠

1. Move Rails Logs To STDOUT

• create var ansible/group_vars/all/vars.yml with value "true"
• set env RAILS_LOG_TO_STDOUT in ansible/templates/environment.j2

1. Check logs

• Run make development-setup-env (dont forget run it everytime after new variable added)
• Restart Docker Compose

1. Move master.key to vars

• Move rails_key_master from services/app/config/master.key to ansible/group_vars/all/vault.yml
• set env RAILS_MASTER_KEY in ansible/templates/environment.j2

https://www.engineyard.com/blog/rails-encrypted-credentials-on-rails-5.2⁠

1. Add tasks for encrypt and decrypt ansible vaults to make-ansible.mk

https://docs.ansible.com/ansible/2.4/vault.html⁠

ansible-vaults-encrypt:
        ansible-vault encrypt ansible/development/group_vars/all/vault.yml
        ansible-vault encrypt ansible/group_vars/all/vault.yml

ansible-vaults-decrypt:
        ansible-vault decrypt ansible/development/group_vars/all/vault.yml
        ansible-vault encrypt ansible/group_vars/all/vault.yml

Always encrypt before commit!

1. Create services/app/Dockerfile.production

• Install deps
• Copy project to image
• Dont run assets compilation

1. Configure rails logger for using stdout in production environment services/app/config/environment/production.rb

2. Check locally that production image can be built

3. Create repository workshop-devops-app on Docker Cloud

• Join with bitbucket
• Configure autobuild for latest and tags like v3 or v5
• Create git tag and wait for building new version

1. Create services/app/docker-compose.test.yml

• https://docs.docker.com/docker-cloud/builds/automated-testing/⁠

1. Checkpoint

• Build new image version and ensure that tests was passed on the Docker Cloud

1. Add nginx to services

• Create services/nginx/<you_domain_name>.conf
• Create services/nginx/Dockerfile and copy config to /etc/nginx/conf.d/<you_domain_name.conf
• Create workshop-devops-nginx repository on docker cloud
• Connect with bitbucket
• Autbuild latest on commit

1. Add remote servers to ansible/production/inventory

2. Install Ansible deps

https://galaxy.ansible.com/⁠

• use ansible galaxy for install https://github.com/geerlingguy/ansible-role-docker⁠

• Create task ansible-deps-install

  ansible-deps-install: ansible-galaxy install -r requirements.yml

1. Configure remote servers

• write playbook ansible/site.yml

  • setup docker
  • write ~/.env for production environment
  • create docker network for nginx and app

• write make production-setup

  ansible-playbook ansible/site.yml -i ansible/production -u ubuntu -vv

• Run and check it

1. Setup AWS by hands
2. Write ansible/deploy.yml playbook

• download images
• create containers
• write make production-deploy

1. Deploy application + nginx

• Check your domain

1. Create task make production-deploy-app which deploy only application

• use the same playbook with tag app