Containers - Historial de revisiones

Pneira: /* Exercise 7 */

2022-01-26T09:47:58Z

‎Exercise 7

Antrodrui2: /* Exercise 7 */

2022-01-14T16:59:54Z

‎Exercise 7

Pneira: /* Exercise 6 */

2022-01-14T16:55:05Z

‎Exercise 6

Pneira: /* Exercise 1: Variant of httpd */

2022-01-14T16:44:15Z

‎Exercise 1: Variant of httpd

Pneira: /* Step 11: Create our own docker image */ use ubuntu image instead of alpine

2022-01-11T15:48:11Z

‎Step 11: Create our own docker image: use ubuntu image instead of alpine

Pneira en 16:52 7 ene 2022

2022-01-07T16:52:39Z

Mostrar los cambios

Pneira: Página creada con «In this practice we will learn how to use [https://es.wikipedia.org/wiki/Docker_(software) docker] to deploy containers. = Step 1: Installing docker = Let's add a new rep...»

2022-01-07T16:50:59Z

Página creada con «In this practice we will learn how to use [https://es.wikipedia.org/wiki/Docker_(software) docker] to deploy containers. = Step 1: Installing docker = Let's add a new rep...»

Página nueva

In this practice we will learn how to use [https://es.wikipedia.org/wiki/Docker_(software) docker] to deploy containers.

= Step 1: Installing docker =

Let's add a new repository, since docker is not in the repositories
official repositories:

<syntaxhighlight lang="bash">
sudo apt update
sudo apt install docker.io
</syntaxhighlight>

To see if everything is OK and it has been installed correctly, we will check that the
service is active:

<syntaxhighlight lang="bash">
sudo service docker status
</syntaxhighlight>

It should display something similar to the following:

<syntaxhighlight lang="bash">
● docker.service - Docker Application Container Engine.
Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
Active: active (running) since Mon 2019-08-26 09:41:40 UTC; 37s ago
Docs: https://docs.docker.com
Main PID: 3630 (dockerd)
Tasks: 8
CGroup: /system.slice/docker.service
└─3630 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
</syntaxhighlight>

Press the 'q' key to exit.

If the service appears inactive, you can launch it with:

<syntaxhighlight lang="bash">
sudo service docker start
</syntaxhighlight>

= Step 2: Launch docker with our user =

To avoid needing sudo when using docker, we will add our user to the group
docker:

<syntaxhighlight lang="bash">
sudo usermod -aG docker ubuntu
</syntaxhighlight>

For the change to take effect, we will need to log out of our user's
user and open it again. We can easily do this by pressing CTRL + D and
re-inserting our credentials.

= Step 3: DockerHub container image repository

Docker offers a cloud service called ''DockerHub'' that can be employed as a social network to share your Docker images. In ''DockerHub'' there are also preconfigured container images of software, many of them official (offered by the software manufacturer itself) that can be used as a basis for building new images tailored to our needs.

We will be able to perform searches in this repository ''DockerHub'' you can use the following command:

<syntaxhighlight lang="bash">
docker search hello-world
</syntaxhighlight>

To download the ''hello-world'' image we can use the ''pull'' command:

<syntaxhighlight lang="bash">
docker pull hello-world
</syntaxhighlight>

We can also publish our own images, this requires '''user registration'''' in the '''DockerHub''' cloud, which is '''not'''' mandatory for the realization of this practice. To upload an image, you have to validate yourself as a user in the '''DockerHub''' cloud:

<syntaxhighlight lang="bash">
docker login
</syntaxhighlight>

After entering your login and password, you can start publishing your own images.

<syntaxhighlight lang="bash">
docker push MY_IMAGE
</syntaxhighlight>

= Step 4: Check images on our machine =

To see the images we have on our machine, we will use the command:

<syntaxhighlight lang="bash">
docker images
</syntaxhighlight>

Initially, we don't have images in storage, we can download the official Ubuntu image:

<syntaxhighlight lang="bash">
docker pull ubuntu:latest
</syntaxhighlight>

Now yes, the ''ubuntu'' image should appear.

Comment also that each image can have several tags, for example, the ubuntu image, when we have seen it in the list of images, came with the tag latest, which is the tag that is downloaded by default, but we can specify another, for example:

<syntaxhighlight lang="bash">
docker pull ubuntu:bionic
</syntaxhighlight>

To bring us the version of the Ubuntu image ''bionic'' (18.04).

Now we will have two images with different label, which would be like the different versions of each image.

= Step 5: Launch a container

A container is nothing more than a docker image running, it would be similar to a
a virtual machine, although much lighter.

To create a container, we will use an image, in this case, the image
hello-world image. We do the following:

<syntaxhighlight lang="bash">
docker run hello-world
</syntaxhighlight>

This will show us the following message if everything is correct:

<syntaxhighlight lang="bash">
Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
1. The Docker client contacted the Docker daemon.
2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
(amd64)
3. The Docker daemon created a new container from that image which runs the
executable that produces the output you are currently reading.
4. The Docker daemon streamed that output to the Docker client, which sent it
to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
$ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
https://hub.docker.com/

For more examples and ideas, visit:
https://docs.docker.com/get-started/
</syntaxhighlight>

When creating containers using the 'run' command, we have several options:

== Step 5.1: Run a terminal on the container in interactive mode (-ti) ==

For this example we are going to use a different image, in this case we are going to use an ubuntu image.

We are going to launch a container and run a terminal in which we are going to run the program '''bash'''' which offers me a command interpreter:

<syntaxhighlight lang="bash">
docker run -ti ubuntu bash
</syntaxhighlight>

The ''-t'' option indicates that a terminal is created in the container. And the ''-i'' option indicates that the container is run in interactive mode.

When accessing the ''ubuntu'' container, a ''hash'' is displayed at the shell prompt, which identifies the container instance (this value is similar to the one displayed by the ''docker container ls'' command).

To exit the container, type 'exit' or press 'CTRL + D'.

== Step 5.2 Running in the background (-d) ==

<syntaxhighlight lang="bash">
docker run -d hello-world
</syntaxhighlight>

It will show us the container id and run in the background, so the output we got before is now not shown. In order to see this output,
we can use the logs command and the display id above:

<syntaxhighlight lang="bash">
docker logs 2ec1daae4676a4e84dc04fd91399c1dfe92119544ff12ee307991fe573d3db64
</syntaxhighlight>

== Step 5.3: Adding environment variables to a container == Step 5.3.

We will use the above image, and we will add an environment variable
called TEST containing the value 'test'. In addition, we will also run the
terminal as before, to check with the echo command, that the environment variable is created correctly.
environment variable is created correctly:

<syntaxhighlight lang="bash">
docker run -ti -e TEST=test ubuntu bash
</syntaxhighlight>

Now, from the container we can check the value of the ''$TEST'' environment variable.

<syntaxhighlight lang="bash">
echo $TEST
test
</syntaxhighlight>

= Step 6: List running containers =

We have been testing and running containers in the previous step, let's see where are these containers we have run, and then we will see some more options of the run command.

We have two options for viewing the containers:

<syntaxhighlight lang="bash">
docker container ls -a
</syntaxhighlight>

or the short version:

<syntaxhighlight lang="bash">
docker ps -a
</syntaxhighlight>

Both do the same thing, and should show us output similar to the following:

<syntaxhighlight lang="bash">
CONTAINER ID CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
e2bde5f5500c ubuntu "bash" 6 minutes ago Exited (0) 2 seconds ago pensive_sammet
544ad27dbc3c ubuntu "bash" 7 minutes ago Exited (0) 7 minutes ago serene_elgamal
</syntaxhighlight>

In the information we will see that the container has the status exited, that means that it is not running and has already finished. Let's do a test to see a container running:

<syntaxhighlight lang="bash">
docker run -d ubuntu sleep 30
</syntaxhighlight>

With the sleep 30 command we wait 30 seconds until the command finishes, so during those 30 seconds, the container will be running, let's see it:

<syntaxhighlight lang="bash">
docker ps -a
</syntaxhighlight>

<syntaxhighlight lang="bash">
CONTAINER ID IMAGE IMAGE COMMAND CREATED STATUS PORTS NAMES
eacceb27d52d ubuntu "sleep 30" 12 seconds ago Up 11 seconds sharp_pasteur
</syntaxhighlight>

Let's see some more options of the ''run'' command.

== Step 6.1: Give a name to the container (--name) ==

By default, docker will automatically create a name as we have seen in the outputs of the ''docker ps -a'' command. We can set the container name we want with the ''--name'' option:

<syntaxhighlight lang="bash">
docker run -d --name my_ubuntu ubuntu
</syntaxhighlight>

== Step 6.2: Remove container when finished (--rm) ==

Let's mix everything seen above:

* Launch in the background (-d)
* Run container for 30 seconds (sleep 30)
* Give a name to the image (--name)
* Delete container when finished (--rm)

<syntaxhighlight lang="bash">
docker run -d --rm --name bye-bye ubuntu sleep 30
</syntaxhighlight>

Before and after the 30 seconds have passed, we can check that the container has disappeared.

<syntaxhighlight lang="bash">
docker ps -a
</syntaxhighlight>

= Step 7: Stopping and deleting containers =

Containers we can stop or delete them, let's see how to do it. First of all, we
nothing, we will delete all the containers that are finished, to do this:

<syntaxhighlight lang="bash">
docker container prune
docker ps -a
</syntaxhighlight>

We've got everything clean to continue, now let's create a container,
using a linux command that doesn't terminate, so that the container will keep running infinitely: </syntaxhighlight>.
running the container infinitely:

<syntaxhighlight lang="bash">
docker run -d -ti --name my_container ubuntu bash
docker ps -a
</syntaxhighlight>

Let's stop it (we can use the given name or id):

<syntaxhighlight lang="bash">
docker stop my_container
docker stop e4901956f108
docker ps -a
</syntaxhighlight>

We'll see that it's finished, and now we're going to delete it, but only this
container, not like previously we deleted all of them. The same as to stop it,
we can use the name or the id.

<syntaxhighlight lang="bash">
docker container rm my_container
docker container rm my_container
docker ps -a
</syntaxhighlight>

We will see that we no longer have the container and it is correctly removed.

= Step 8: Connect to a container that is running in the background =

Let's re-run a container that does not terminate:

<syntaxhighlight lang="bash">
docker run -d -ti --name to_attach ubuntu bash
</syntaxhighlight>

Now, let's connect to this container that is running in the background.
background:

<syntaxhighlight lang="bash">
docker attach to_attach
</syntaxhighlight>

We will see the bash command running, to finish, we do a 'CTRL + C', and now, we will see what has happened to the container:

<syntaxhighlight lang="bash">
docker ps -a
</syntaxhighlight>

We will see it stopped, because what we have done was to connect to the container
and stop the command that was running, so now we've got the container
finished.

= Step 9: Execute another command in a container =

Let's see again how to execute a command in a container that is already running.
already running:

<syntaxhighlight lang="bash">
docker run -d -ti --name to_exec ubuntu bash
</syntaxhighlight>

Now, let's run a command on that container. The exec command is similar
to the run command, but to execute a command inside a container:

<syntaxhighlight lang="bash">
docker exec -ti to_exec ls
</syntaxhighlight>

We are now inside the container created earlier:

<syntaxhighlight lang="bash">
ps -a
</syntaxhighlight>

Here we will see in the list of running processes.

Now let's exit the container, by typing 'exit' or 'CTRL + D', and
let's check the status of the container:

<syntaxhighlight lang="bash">
docker ps -a
</syntaxhighlight>

Now we will see that the container is still running, not like in the previous step.

= Step 10: Persistence in containers =

We are going to see that containers do not keep the data by default, they only give us
give us a service but the data is NOT persistent. Let's create a container that
we are going to leave running:

<syntaxhighlight lang="bash">
docker run -d -ti --name to_expire ubuntu bash
</syntaxhighlight>

Now, let's create a folder in the container and check that this folder
exists:

<syntaxhighlight lang="bash">
docker exec to_expire mkdir test
docker exec to_expire ls
</syntaxhighlight>

We'll see that the folder exists, but what happens if we delete the docker and
recreate one?

<syntaxhighlight lang="bash">
docker container stop to_expire
docker container rm to_expire
docker run -d -ti --name to_expire ubuntu bash
docker exec to_expire ls
</syntaxhighlight>

We can check that the folder created earlier, does not exist if the
container terminates. If we would like to maintain a persistence of data, we have
several options:

== Step 10.1: Maintain the persistence by changing the base image ==

We repeat the previous steps, but before stopping the container, we are going to
save the state of the container in the image:

<syntaxhighlight lang="bash">
docker run -d -ti --name to_save ubuntu bash
docker exec to_save mkdir test
docker commit to_save ubuntu
docker stop to_save
</syntaxhighlight>

Now, let's stop the container and run a new one to test that the data
has persisted:

<syntaxhighlight lang="bash">
docker run -d -ti --name to_save_v2 ubuntu:with_directory_test bash
docker exec to_save_v2 ls
</syntaxhighlight>

This creates an ubuntu image with the label "con_directory_test".

== Step 10.2: Maintain persistence by creating volumes ==

The other option to maintain data is to mount a volume by running the
container. First we will create a folder that will act as a volume on our machine, which will be the one we will mount later.
machine, which will be the one we then mount for docker:

<syntaxhighlight lang="bash">
mkdir /home/ubuntu/volume
</syntaxhighlight>

Now we are going to mount the folder by running the container, we do it with the
-v option, which has 3 fields separated by ':':

# The volume on our machine.
# Where the volume will be mounted inside the container
# Mounting options, e.g. rw (read and write) or ro (read only)

<syntaxhighlight lang="bash">
docker run --rm -ti -v /home/ubuntu/volume:/volume:rw ubuntu bash
mkdir /volume/test
touch /volume/test/file
exit
</syntaxhighlight>

Once we exit the container, we can see that on our machine are.
the data:

<syntaxhighlight lang="bash">
ls /home/ubuntu/volume/
ls /home/ubuntu/volume/test
</syntaxhighlight>

The next time we run a container, if we mount that volume, the data will be there.
data will be there, plus this way has the benefit of sharing data between our machine and the
our machine and the container in a simple way.

= Step 11: Create our own docker image =

To create a container image with a Python hug application, we first create the folder that will contain the files that allow us to create the image.

<syntaxhighlight lang="bash">
mkdir miapp
cd miapp
</syntaxhighlight>

We define a ''Dockerfile'' file to define the image:

<syntaxhighlight lang="bash">
FROM python:alpine

ENV USERNAME="username"
RUN mkdir /app
RUN pip install hug
COPY endpoint.py /app
WORKDIR /app
CMD hug -f endpoint.py
</syntaxhighlight>

Alternatively, you can create a [[Creating your own image using Ubuntu from base|Dockerfile using Ubuntu image]] as a base instead of Alpine.

And add the file ''endpoint.py'' which uses the Python hug framework with the following content:

<syntaxhighlight lang="bash">
import hug

@hug.get('/welcome')
def welcome(username="unknown"):
""" Say welcome to username """
return "Welcome " + username
</syntaxhighlight>

This file is an example of using Python hug. If we make a request to /welcome?username="LSO", this will return the message "Welcome LSO".

Once we have the two files created in our virtual machine, we can build our image:

<syntaxhighlight lang="bash">
docker build -t app:v1 -f Dockerfile .
</syntaxhighlight>

Let's explain what each line is for:

* FROM: will serve to base on an existing image, in this case, a python alpine image, which contains python and does not take up much space.
* ENV: to create environment variables
* RUN: to execute commands, either to create a folder, install dependencies or any other option we need.
* COPY: to copy data from our machine to the image
* WORKDIR: to change the working directory.
* CMD: this command will be executed by default when starting a container from this image.

This will build a docker image based on python:alpine, in which we have saved our small application, and it will
saved our small application and it will run when we run a container based on that image.
container based on that image. To check that the image has been created
correctly, we list the images, and we should get an image with the name 'app' and tag
name 'app' and tag 'v1':

<syntaxhighlight lang="bash">
docker images
</syntaxhighlight>

Now let's create a container for our image, and we'll add a new
option, -p 8001:8000. This option will cause the container's internal port 8000
to be exposed on port 8001 on our machine:

<syntaxhighlight lang="bash">
docker run --name my-app --rm -d -p 8001:8000 app:v1
</syntaxhighlight>

Now let's test that our image and code works. On our
machine we will do:

<syntaxhighlight lang="bash">
curl -X GET http://localhost:8001/welcome?username=LSO
</syntaxhighlight>

We will check that the output of the curl command, is "Welcome LSO".

Before we finish, let's check another little detail that we added in
our image, the environment variable USERNAME, let's check that it works:

<syntaxhighlight lang="bash">
docker exec -ti my-app ash
echo $USERNAME
</syntaxhighlight>

It works correctly, but when running the container, we can change this
environment variable as we saw in one of the previous steps:

<syntaxhighlight lang="bash">
docker run --rm -ti -e USERNAME=me app:v1 ash
echo $USERNAME
</syntaxhighlight>

This will help us to have default options and the user can change it at will.
change it at will, such as passwords or other details.

← Revisión anterior		Revisión del 09:47 26 ene 2022
Línea 1028:		Línea 1028:
	* Copy an index.html file that contains <html>hello world</html> into /usr/share/nginx/html		* Copy an index.html file that contains <html>hello world</html> into /usr/share/nginx/html
	* Create a container image which automates all of steps that are described above using the name mynginx. Run an instance of it with a port mapping of TCP/8888 to TCP/80. Verify that your image works.		* Create a container image which automates all of steps that are described above using the name mynginx. Run an instance of it with a port mapping of TCP/8888 to TCP/80. Verify that your image works.
		+
		+	== Exercise 8 ==
		+
		+	* Get the ''ubuntu'' container image.
		+	* Install the ''python3-bottle'' package. Python bottle is a framework for web sites.
		+	* Create a simple .py hello world program for Python Bottle
		+
		+	<source lang="bash">
		+	from bottle import route, run
		+
		+	@route('/')
		+	@route('/hello/<name>')
		+	def greet(name='Stranger'):
		+	return 'Hello %s, how are you?'%name
		+
		+	run(host='localhost', port=8080, debug=True)
		+	</source>
		+
		+	* Run the program.
		+	* Create a container image that automates the steps above.
		+	* Deploy the container image, map port localhost TCP/8888 to container TCP/8080. Use curl to validate that the container is running.

@@ Línea 1025: / Línea 1025: @@
 * Get the ''nginx'' container image.
-* Run a container instance based on this image (in interactive mode and with display output on the terminal), use the name ''www'' for this container. Map local port TCP/8888 to container port TCP/80. Run the container as a daemon. Verify that the image is running and show logs.
+* Run a container instance based on this image (in interactive mode and with display output on the terminal), use the name ''www'' for this container. Map local port TCP/8888 to container port TCP/80. Verify that the image is running and show logs.
 * Copy an index.html file that contains <html>hello world</html> into /usr/share/nginx/html
 * Create a container image which automates all of steps that are described above using the name mynginx. Run an instance of it with a port mapping of TCP/8888 to TCP/80. Verify that your image works.

← Revisión anterior		Revisión del 16:55 14 ene 2022
Línea 1019:		Línea 1019:

	curl -X GET http://127.0.0.1:8888/php/		curl -X GET http://127.0.0.1:8888/php/
		+
		+	== Exercise 7 ==
		+
		+	NGINX is a popular opensource web server.
		+
		+	* Get the ''nginx'' container image.
		+	* Run a container instance based on this image (in interactive mode and with display output on the terminal), use the name ''www'' for this container. Map local port TCP/8888 to container port TCP/80. Run the container as a daemon. Verify that the image is running and show logs.
		+	* Copy an index.html file that contains <html>hello world</html> into /usr/share/nginx/html
		+	* Create a container image which automates all of steps that are described above using the name mynginx. Run an instance of it with a port mapping of TCP/8888 to TCP/80. Verify that your image works.

← Revisión anterior		Revisión del 16:44 14 ene 2022
Línea 756:		Línea 756:

	= Step 14: Exercises		= Step 14: Exercises
		+
		+	= Step 14: Exercise =

	== Exercise 1: Variant of httpd ==		== Exercise 1: Variant of httpd ==

@@ Línea 468: / Línea 468: @@
 <syntaxhighlight lang="bash">
-FROM python:alpine
+FROM ubuntu
 ENV USERNAME="username"
 RUN mkdir /app
 COPY endpoint.py /app
 WORKDIR /app
@@ Línea 595: / Línea 596: @@
 docker rmi fce289e99eb9
 </syntaxhighlight>
 = Step 13: Several docker at once (docker-compose) =