Docker Compose : Installation & Multicontainer Application Deployment

In order to do something useful with containers, they need to be organized as a part of a project, usually referred to as an application. There are multiple ways of orchestrating a Docker application, but Docker Compose is perhaps the most human-friendly. It is a tool for defining and running multi-container Docker applications. It allows users to launch, execute, communicate and shut containers with one coordinated command.

It makes it easier for users to orchestrate the processes of Docker containers, including starting up, shutting down, and setting up intra-container linking and volumes.

In this blog, I’ve covered

• What is Docker Compose 
• Why Docker Compose
• Features 
• Common use cases
• Install Docker Compose
• Containerise Application using Docker Compose
• Docker-compose file
• Dockerfile vs docker-compose

What is Docker Compose?

Compose is a tool for defining and running multi-container Docker applications. With Compose, you utilize a YAML file to configure your application’s services. Then, with one command, you create and begin all the services from your configuration. Compose works in all environments: production, staging, development, testing, as well as CI workflows.

Using Compose is basically a three-step process:

• Define your app’s environment with a Dockerfile so it can be reproduced anywhere.
• Define the services that make up your app in docker-compose.yml so they can be run together in an isolated environment.
• Run docker-compose up and Compose starts and runs your entire app.

Why Docker Compose?

Docker has made it easier to set up a local development environment. However, if you want to create more than one container for your application, you have to create several Docker files. This adds to a load of maintaining them and is also quite time-consuming.

It solves this problem by allowing you to use a YAML file to operate multi-container applications at once. You can set the desired amount of containers counts, their builds, and storage designs, and then with a single set of commands, you can build, run, and configure all the containers.

Features

The features of Compose that make it effective are:

• Multiple isolated environments on one host.
• Preserve volume data once containers are created.
• Only recreate containers that have modified.
• Variables and moving a composition between the environment.

Common use cases

Compose can be used in many different ways. Some common use cases are outlined below.

Development environments

When you’re developing software, the ability to run an application in an isolated environment and interact with it’s crucial. The Compose command-line tool can be used to create the environment and interact with it.

Automated testing environments

An important part of any Continuous Deployment or Continuous Integration method is the automated test suite. Automated end-to-end testing requires an environment in which to run tests. Compose provides a convenient way to create and destroy isolated testing environments for your test suite.

Compose file, you can create and destroy these environments in just a few commands:

$ docker-compose up -d
$ ./run_tests
$ docker-compose down

Install Docker Compose

Follow the steps below to install the version from its official GitHub repository. You’ll be able to install it from the Ubuntu repository by running sudo apt install docker-compose. However, this option doesn’t guarantee you’re downloading the recent version.

sudo apt update

sudo apt upgrade

curl

sudo apt install curl

sudo curl -L "https://github.com/docker/compose/releases/download/1.26.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

sudo chmod +x /usr/local/bin/docker-compose

docker–compose –version

$ sudo apt-get update -y
$ sudo apt install docker-compose -y

$ mkdir stackdemo
$ cd stackdemo

$ vim app.py

import time
import redis
from flask import Flask
app = Flask(__name__)
cache = redis.Redis(host='redis', port=6379)
def get_hit_count():
 retries = 5
 while True:
 try:

support@k21academy.com 40
 return cache.incr('hits')
 except redis.exceptions.ConnectionError as exc:
 if retries == 0:
 raise exc
 retries -= 1
 time.sleep(0.5)
@app.route('/')
def hello():
 count = get_hit_count()
 return 'Hello World! I have been seen {} times.\n'.format(count)

flask 
redis

$ vim Dockerfile

FROM python:3.7-alpine
WORKDIR /code
ENV FLASK_APP app.py
ENV FLASK_RUN_HOST 0.0.0.0
RUN apk add --no-cache gcc musl-dev linux-headers
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
COPY . .
CMD ["flask", "run"]

$ vim docker-compose.yml

version: '3'
services:
web:
build: .
ports:
- "5000:5000"
redis:
image: "redis:alpine"

$ docker-compose up -d

$ docker-compose ps

$ docker ps

$ docker-compose down

version: '3'
services:
  web:
    build: .
    ports:
     - "8080:80"
  db:
    image: mysql
    ports:
    - "3306:3306"
    environment:
    - MYSQL_ROOT_PASSWORD=password
    - MYSQL_USER=user
    - MYSQL_PASSWORD=password
    - MYSQL_DATABASE=demodb

The post Docker Compose : Installation & Multicontainer Application Deployment appeared first on Cloud Training Program.