====== Docker In Linux ======

Tested in Ubuntu.

===== Installation =====

//This is a summarization of the full article found [[https://docs.docker.com/install/linux/docker-ce/ubuntu/#upgrade-docker-ce|here]].//

I usually add a repo to the package manager for stuff like this, but I decided to use a standalone .deb file this time.

Since Linux Mint 19 is built on Ubuntu 18.04 (Bionic Beaver), I downloaded the latest .deb file from [[https://download.docker.com/linux/ubuntu/dists/bionic/pool/stable/amd64/|here]].

After installation, the Docker daemon starts automatically.

<WRAP center round tip 60%>
If you don't want to require 'sudo' with every docker command, add your userid to the 'docker' group.
</WRAP>

Verify the Docker installation with the following command:

<code bash>
sudo docker run hello-world
</code>

If the Docker installation is valid, the hello-world image will be downloaded from Docker Hub, and will run. It will print out an informational message similar to this:

<code>
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/engine/userguide/
</code>

…and then exit.

===== Manage Containers =====

You can display a list of all your installed images and their associated containers with this command:

<code bash>
sudo docker ps -a
</code>

The results list will look something like this:

^ CONTAINER ID ^ IMAGE ^ COMMAND ^ CREATED ^ STATUS ^ PORTS ^ NAMES ^
| 3467bc449fe9 | hello-world | "/hello" | 24 hours ago | Exited (0) 24 hours ago | | friendly_haibt |
| 890e2533976a | hello-world | "/hello" | 25 hours ago | Exited (0) 25 hours ago | | angry_agnesi |

If you’d like to remove a container, use the **docker rm** command. For example, if I wanted to remove the **friendly_haibt** container for the **hello-world** image, I’d do this:

<code bash>
sudo docker rm friendly_haibt
</code>

Then, when I run the docker ps command again, I’ll see this:

^ CONTAINER ID ^ IMAGE ^ COMMAND ^ CREATED ^ STATUS ^ PORTS ^ NAMES ^
| 890e2533976a | hello-world | "/hello" | 25 hours ago | Exited (0) 25 hours ago | | angry_agnesi |

<WRAP center round alert 60%>
After you remove a persistent container, all data associated with the container is also removed, and is not recoverable. Be careful!
</WRAP>

Dump log file for a container:

<code bash>
sudo docker log <container-name>
</code>

Stop a running container:

<code bash>
sudo docker stop <container-name>
</code>

Restart a stopped container:

<code bash>
sudo docker restart <container-name>
</code>

===== Example: BusyBox container =====

A //very// simple example using BusyBox UNIX tools:

<code bash>
sudo docker run -it --rm busybox
</code>

This command drops you into a sh shell in a BusyBox environment, and the container is automatically removed when you exit.

===== Helper Script For Container Examples =====

<file python dockit.py>
    #!/usr/bin/python3
     
    import os
    import sys
     
    class CDockerMgr:
    	dockerCmd = 'sudo docker'
     
    	def __init__(self):
    		pass
     
    	def ExecuteBaseCommand(self, currentCommand):
    		if currentCommand == 'status':
    			self.ExecDocker("ps -a")
    		else:
    			self.ShowHelp()
     
    	def ExecuteContainerCommand(self, currentContainer, currentCommand):
    		if currentContainer == 'sql1':
    			if currentCommand == 'start':
    				self.ExecDocker("restart {0}".format(currentContainer))
    			elif currentCommand == 'stop':
    				self.ExecDocker("stop {0}".format(currentContainer))
    			elif currentCommand == 'bash':
    				self.ExecDocker("exec -it {0} 'bash'".format(currentContainer))
    			else:
    				self.ShowHelp()
    		elif currentContainer == 'busybox':
    			if currentCommand == 'run':
    				self.ExecDocker("run -it --rm {0}".format(currentContainer))
    			else:
    				self.ShowHelp()
    		else:
    			self.ShowHelp()
     
    	def ExecDocker(self, args):
    		fullCmd = "{0} {1}".format(self.dockerCmd, args)
    		os.system(fullCmd)
    		exit(0)
     
    	def ShowHelp(self):
    		print("USAGE:")
    		print("\tdockit <container> <command>")
    		print("")
    		print("Valid containers and commands:")
    		print("\tstatus")
    		print("\tsql1")
    		print("\t\tstart")
    		print("\t\tstop")
    		print("\t\tbash")
    		print("\tbusybox")
    		print("\t\trun")
     
    		exit(0)
     
    myDockerMgr = CDockerMgr()
     
    if len(sys.argv) == 2:
    	myDockerMgr.ExecuteBaseCommand(sys.argv[1])
    elif len(sys.argv) == 3:
    	myDockerMgr.ExecuteContainerCommand(sys.argv[1], sys.argv[2])
    else:
    	myDockerMgr.ShowHelp()
</file>

{{tag>docker}}