Please visit my website and subscribe to my youtube channel for more articles
Thank you for Subscribing! If you have not, Subscribe now! DevOps4Solutions helps in providing end to end solution and…
Install Docker on AWS
sudo yum update -y
sudo yum install -y docker
sudo service docker start
sudo usermod -a -G docker ec2-user
Docker version 17.09.1-ce, build
Docker installed successfully.
Install Docker-Compose. Get the latest one from here https://github.com/docker/compose/releases
curl -L https://github.com/docker/compose/releases/download/1.20.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose
Test Docker installation
Run hello-world image
docker run hello-world
Build a Image
Create a Dockerfile,requirements.txt,app.py
docker build -t friendlyhello .docker image ls
docker run -p 4000:80 friendlyhello
RUn the app in detached modedocker run -d -p 4000:80 friendlyhello
docker stop containerid
Push image in Docker Hub
Now you can run your image from anywhere
docker run -p 4000:80 username/repository:tag
Till now, we have created an image using Dockerfile,push it to DOckerhub so that anyone can use it now.
Some useful commands
Create DockerImage with commit option
- Run a container from the ubuntu and connect it to its command line:
docker run -i -t ubuntu /bin/bash
2. Install the Git toolkit:
root@dee2cb192c6c:/# apt-get update
root@dee2cb192c6c:/# apt-get install -y git
- Check if the Git toolkit is installed:
root@dee2cb192c6c:/# which git
- Exit the container:
- Check what has changed in the container comparing it to the ubuntu image:
$ docker diff dee2cb192c6c
The command should print a list of all files changed in the container.
- Commit the container to the image:
$ docker commit dee2cb192c6c ubuntu_with_git
Using the exact same method, we can build ubuntu_with_git_and_jdk on top of the ubuntu_with_git image:
$ docker run -i -t ubuntu_with_git /bin/bash
root@6ee6401ed8b8:/# apt-get install -y openjdk-8-jdk
$ docker commit 6ee6401ed8b8 ubuntu_with_git_and_jdk
Create Image directly using Dockerfile
Create a Docker file with below contents
MAINTAINER Rafal Leszko
RUN apt-get update && \
apt-get install -y python
COPY hello.py .
ENTRYPOINT [“python”, “hello.py”]
Creata a hello.py
print “Hello World from Python!”
docker build -t hello_world_python .
$ docker run hello_world_python
Let’s start with an example and specify the volume with the -v <host_path>:<container_path> option and connect to the container:
$ docker run -i -t -v ~/docker_ubuntu:/host_directory ubuntu:16.04 /bin/bash
Now, we can create an empty file in host_directory in the container:
root@01bf73826624:/# touch host_directory/file.txt
Let’s check if the file was created in the Docker host’s filesystem:
exit$ ls ~/docker_ubuntu/
We can see that the filesystem was shared and the data was therefore persisted permanently. We can now stop the container and run a new one to see that our file will still be there:
$ docker stop 01bf73826624$ docker run -i -t -v ~/docker_ubuntu:/host_directory ubuntu:16.04 /bin/bash
root@a9e0df194f1f:/# ls host_directory/
Instead of specifying the volume with the -v flag, it’s possible to specify the volume as an instruction in the Dockerfile, for example:
Some useful commands
docker ps ( to show all running containers)
docker ps -a ( to show all containers(stopped and running)
docker exec -it 4a53d243816e bash ( To go inside a container)
Docker setup has completed succesfully with some basic knowledge.
Create a Docker-compose.yml/scale up application
is a YAML file that defines how Docker containers should behave in production.
docker-compose.yml file tells Docker to do the following:
- Pull the image we uploaded in step 2 from the registry.
- Run 5 instances of that image as a service called
web, limiting each one to use, at most, 10% of the CPU (across all cores), and 50MB of RAM.
- Immediately restart containers if one fails.
- Map port 80 on the host to
web’s port 80.
web’s containers to share port 80 via a load-balanced network called
webnet. (Internally, the containers themselves publish to
web’s port 80 at an ephemeral port.)
- Define the
webnetnetwork with the default settings (which is a load-balanced overlay network).
docker swarm initdocker stack deploy -c docker-compose.yml getstartedlab
Our single service stack is running 5 container instances of our deployed image on one host.
docker service ps getstartedlab_webdocker container ls -q
You can run
curl -4 http://localhost several times in a row and you will get different hostnames
You can update docker-compose.yml file and re-run the stack command .Docker performs an in-place update, no need to tear the stack down first or kill any containers.
docker stack rm getstartedlab
docker swarm leave --force
We have learnt how it should run in production by turning it into a service, scaling it up 5x in the process.
CLuster in Docker
Now we will deploy this application onto a cluster, running it on multiple machines. Multi-container, multi-machine applications are made possible by joining multiple machines into a “Dockerized” cluster called a swarm.
Swarm — group of machines that are running Docker and joined into a cluster.
Swarm managers can use several strategies to run containers, such as “emptiest node” — which fills the least utilized machines with containers. Or “global”, which ensures that each machine gets exactly one instance of the specified container. You instruct the swarm manager to use these strategies in the Compose file, just like the one you have already been using.
Swarm managers are the only machines in a swarm that can execute your commands, or authorize other machines to join the swarm as workers. Workers are just there to provide capacity and do not have the authority to tell any other machine what it can and cannot do.
docker swarm init to enable swarm mode and make your current machine a swarm manager then run
docker swarm join on other machines to have them join the swarm as workers
Install Docker-machine on AWS EC2
curl -L https://github.com/docker/machine/releases/download/v0.14.0/docker-machine-`uname -s`-`uname -m` >/tmp/docker-machine && \
sudo install /tmp/docker-machine /usr/local/bin/docker-machine