Skip to content

DevOps

Jump to bottom
ILLYAKO edited this page Dec 5, 2022 · 72 revisions

DevOps foundation

Docker, Docker Compose

Test (Unit test and Integration test)

RSpec, Capybara, Selenium

Deploy

Terraform

CI/CD Pipeline (build, test, deploy)

Jenkins

1. Docker

Docker is a platform for running applications and their dependencies in isolated environments called containers, on nearly any operating system. Homebrew (brew.sh)for installing applications on Mac(Linux) Aptitude, YUM, and YaST are package managers that let you install anything on the Mac

1.1. Docker Installation

1.1.1. Install Homebrew on Linux

$ /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

1.1.2. Install Docker on Linux

$ brew install cask docker - cask(third-part repository) installs Docker, Docker CLI, Docker Compose

1.1.3. Install Docker on Windows

1.1.4. Run Docker Desktop (Windows)

1.1.5. Test Docker

$ docker run hello-world

1.2. Dockerfile

The Dockerfile is a manifest that describes the image that the container will use when we run it. All of the configuration dependencies and environment dependencies and everything that the application needs will be expressed within the Dockerfile.
Docker will do a few things.

  1. The Docker reads and parses the Dockerfile.
  2. The Docker fetches the parent image that this image is going to use. If there is no parent image that you're going to use, you would start from scratch.
  3. The Docker runs any commands, within the Dockerfile that is on top of that image, lastly if defined you can set a process that runs whenever a container from that image is spun up.

1.2.1. Docker Hub is a repository of docker images.

The 'alpine' is the smallest version of the image

1.2.2. Dockerfiles lines:

FROM nginx:alpine                                   #parent image:tag

MAINTAINER Illya Korotun <illya.korotun@gmail.com>  #author
COPY website /website                               #copy context into the image host directory to the container directory
COPY nginx.conf /etc/nginx/nginx.cong               #copy the config file to the container

EXPLOSE 80 #we want to map one(80) of the ports on my Mac to the port on the container.

1.2.3. Build docker image

$ docker build --tag website . # create an image with tag/name "website" from "." (current directory)

1.2.4. Run Container

$ docker run --publish 80:80 website # publish on ports HOST:Container

1.3. Docker Compose manifest

Docker compose is a simple and lightweight platform for running multiple container applications in a single stack and creating a network.

1.3.1 docker-compose.yml
version: '3.7'   # docker compose version
services:
  website:       # service name usually equals the container name
    build:       # looking for Dockerfile and build an image
      context: . # Dockerfile address "."-current directory
    ports:       # container ports HOST:Container
      - 80:80    # Dockerfile address "."-current directory
1.3.2 Run docker-comose and build container

$ docker-compose run website

1.3.3 Up docker-comose and build container and make port maping

$ docker-compose up

1.3.4 Show a list of the docker-compose container running in

$ docker-compose ps

1.3.5 Show a list of the docker container running

$ docker ps

1.3.6 Stop the running container and remove the network

$ docker-compose down

2. Testing App with RSpec, Capybara, and Selenium

  • RSpec is a Ruby-based testing framework. RSpec is looking for a folder called Spes and _spec.rb files (ex. page_spec.rb).
  • Capybara is a tool that lets you use a web driver to create a browser and interact with the website. It gets the HTML of a website, run Javascript, and tests things like a button looking like it should look.
  • The web driver, which is what spins up the browser and runs tests against it.
  • Rack Test is a very simple web browser that just renders HTML and tests it, but it can't do more complicated things like running Javascript or computing CSS.
  • Selenium is a web driver that spins up a real web browser and tests against whatever the web browser sees, which is nice because our website does have computed CSS, and spinning up a real web browser and getting the results of that computed CSS.

2.1. RSpec

2.1.1. Create new directories 'spec' and 'spec/unit' in the project root directory

$ mkdir spec
$ mkdir spec/unit

2.1.2. Create a new file page_spec.rb

$ touch spec/unit/page_spec.rb

# spec/unit/page_spec.rb
require 'capybara'
require 'capybara/dsl'

describe "Ecample page render unit tests" do
  it "Shold show the Explore California logo" do
  end
end

2.1.3 Edit docker-compose adding the 'unit-test'

version: "3.7"
services:
  website:
    build:
      context: .
    ports:
      - 80:80
  unit-test:                       # new service
    volumes:                       # mount the existing volume to the container
      - "$PWD:/app"                #current directory to /app
    build:                         # build a new image
      context: .                   #current context
      dockerfile: rspec.dockerfile #spesific dockerfile
    command:
      - --pattern                  # entrypoint option
      - /app/spec/unit/*_spec.rb        # entrypoint option test target

2.1.4 Create new file rspec.dockerfile

$ touch rspec.dockerfile

# create from base ruby image
FROM ruby:alpine 
MAINTAINER Illy Korotun <illya.korotun@gmail.com>

# apk is pacage from alpine
# add package ruby-nokogiri for parsing 
RUN apk add build-base ruby-nokogiri

# install in contaimer from ruby gem library rubygems.org
RUN gem install rspec capybara selenium-webdriver

#Which process should start when the container is starting. Use double equate 
ENTRYPOINT ["rspec"]

Two way say container how to run CMD and ENTRYPOINT
Every container start with the default comand #/bin/sh -c
CMD ["rspec"] # is mean #/bin/sh -c "rspec"

ENTRYPOINT is running the command where it placed
ENTRYPOINT ['option1', 'option2'] # is mean docker run this_image --option1 --option2
ENTRYPOINT ['rspec'] # is mean docker run this_image rspec

2.1.5 Execute docker-compose -d to hide the output of the container

docker-compose up -d website

2.1.6 Run container unit-test with the option to remove the container after use

docker-compose run --rm unit-test
The dot '.' should be shown as result of the successful test

2.1.7 Add tests

Clone this wiki locally