Changes between Initial Version and Version 1 of Docker

Timestamp:

08/29/2022 08:47:11 PM (20 months ago)

Author:

Tim Harvey

Comment:

initial page

Docker

@@ +1 @@
+Using Docker for development
+
+Docker is a set of platform as a service products that use OS-level virtualization to deliver software in packages called containers. The software that hosts the containers is called Docker Engine. Containers are isolated from one another and bundle their own software, libraries and configuration files.
+
+Docker can be hosted on a variety of Operating Systems such as Windows, Linux, and MacOS and is extremely useful to configure OS specific container environments for building embedded Linux firmware.
+
+The various board support packages (BSP) that Gateworks provides for building firmware for the various Gateworks Single Board Computers are typically built on Ubuntu Linux development systems. Due to your personal preference as well as Ubuntu's release schedule you may end up with a development host that does not run Ubuntu or the specific version of Ubuntu that is recommended to build a particular BSP. You can use Docker to create a container with a specific version of Ubuntu to overcome this.
+
+This wiki page does not cover much of Docker, it is to be used as an example.
+
+see also:
+ * [https://petri.com/docker-for-windows-create-a-linux-container-on-windows-10/ Set up Linux Containers on Windows 10]
+ * ​https://hub.docker.com/editions/community/docker-ce-server-ubuntu
+
+
+[=#install]
+== Installing Docker on Ubuntu
+
+Install (from official Docker repo)
+{{{#!bash
+# download deps
+sudo apt-get install apt-transport-https ca-certificates curl software-properties-common
+# install Docker's GPG key
+curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
+# install Docker repo
+sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu  $(lsb_release -cs)  stable"
+#install
+sudo apt-get update
+sudo apt-get install docker-ce docker-ce-cli containerd.io
+}}}
+ - Note the docker group is created but no users are added to it so you need to use sudo to run docker commands or add your user to the docker group (see https://docs.docker.com/install/linux/linux-postinstall/)
+
+It is recommended that you add your user to the docker group so that you do not have to run commands as root. The commands referenced on this page assume you have done that and if you have not, you need to run any docker commands via {{{sudo}}}.
+
+Testing:
+ * test by downloading hello-world image and running it
+{{{#!bash
+docker run hello-world
+}}}
+
+
+References:
+ - https://hub.docker.com/editions/community/docker-ce-server-ubuntu
+
+
+[=#images]
+== Images
+Docker Images represent root filesystems that you can run as a container. These images are built based on a {{{Dockerfile}}} containing a few simple instructions.
+
+Create Image:
+ 1. Create a Dockerfile for the image (each Dockerfile should be in a directory representing the image)
+{{{#!bash
+# create a directory for your images
+mkdir docker-images && cd docker-images
+# create a directory for your image
+mkdir ubuntu-16.04 && cd ubuntu-16.04
+cat << EOF > Dockerfile
+# Docwnload base image ubuntu 16.04
+FROM ubuntu:16.04
+# Update software repo
+RUN apt-get update
+# Install apps we want
+RUN  apt-get install -y build-essential git python \
+libssl-dev ncurses-dev device-tree-compiler bc gawk zlib1g-dev file \
+wget unzip sudo \
+EOF
+}}}
+ 1. Build the image:
+{{{#!bash
+# build docker image
+docker build --tag ubuntu-16.04 .
+}}}
+ 1. List images
+{{{#!bash
+# list images
+docker images
+}}}
+
+Other image commands:
+{{{#!bash
+docker commit <user/image> # save container as an image
+docker save <user/image> #save an image to a tar archive
+docker buid --tag sampleuser/ubuntu . # build docer image from Dockerfile in current dir
+docker load # loads a image from file
+}}}
+
+Note that images are stored system-wide in a 'registry'. These images can be pushed to shared registries to share them.
+
+References:
+ - see https://www.howtoforge.com/tutorial/how-to-create-docker-images-with-dockerfile/
+
+
+[=#tags]
+== Tags
+An image name is made up of slash-separated name components, optionally prefixed by a registry hostname:port. The hostname must comply with standard DNS rules but may not contain underscores. If registry hostname:port is not present the command uses Docker's public registry located at registry-1.docker.io by default. Name components can contain lowercase letters, digits and separators (period, one or two underscores, or one or more dashes).
+
+A tag name must be valid ASCII and may contain lower/upper letters,digits, underscores, periods and dashes.
+
+
+[=#registry]
+A registry is a storage and content deliver system holding named images available in different tagged versions. Users interact with a registry by using docker push and pull commands
+
+The registry is a stateless, open-source, highly scalable server side application that stores and lets you distribute Docker images.
+
+The [https://hub.docker.com/ Docker Hub] provides a free-to-use hosted registry with additional features
+
+commands:
+ * start local registry
+{{{#!bash
+docker run -d -p 5000:5000 --name registry registry:2
+}}}
+ * pull an image from the hub
+{{{#!bash
+docker pull ubuntu
+}}}
+ * tag that image so it points to your local registry
+{{{#!bash
+docker image tag ubuntu localhost:5000/myimage
+}}}
+ * push it
+
+[=#containers]
+== Containers
+A container is a running instance of a system sharing the host machines kernel but using an image root filesystem. When the container is stopped all changes to the filesystem are lost unless you mount volumes within that image to access filesystems on the host.
+
+Running container
+ - Run container with an interactive shell
+{{{#!bash
+# run container interactively
+docker run -it ubuntu-16.04
+}}}
+ - run container with a bind-mount from host {{{/usr/src/}}} to containers {{{/usr/src}}}
+{{{#!bash
+docker run -it --mount type=bind,source=/usr/src,target=/usr/src ubuntu-16.04
+}}}
+ - run container in privileged mode (necessary to perform some root-specific functions like 'mount' within the container)
+{{{#!bash
+docker run --privileged -it --mount type=bind,source=/usr/src,target=/usr/src ubuntu-16.04
+}}}
+ - Notes:
+  - use '--rm' to remove the container after exiting
+  - use '-it' to allocate pseudo-TTY
+  - specify /bin/bash to launch specific shell
+  - use '-w' to set working directory
+  - use '--env foo=bar' or '--env-file ./env.list' to set env vars
+
+Other container commands:
+{{{#!bash
+docker ps # list all running containers
+docker images # list all images on local machine
+docker history <user/image> # list history of an image
+docker port <container> # display exposed port of a running container
+docker run -it <user/image> # runs an image, creating a container and changing the terminal to it
+docker run -p $HOSTPORT:$CONTAINERPORT -d <user/image> # run image in deatched mode wiht port forwarding
+ctrl+p, ctrl+q detach from container
+docker attach <container>
+docker start <container>
+docker stop <container>
+docker inspect <container> # show details
+docker rm -f <container> # delete container
+docker rmi # delete image
+docker tag <user/image:tag> <usr/image:newtag> # apply a new tag to an image
+docker exec <container> shell command # execute a command within a running container
+}}}
+
+
+[=#volumes]
+== Volumes
+Volumes provide a way to share filesystems or more importantly bring non-volatile storage to docker containers.
+
+You can specify volume mounts within image files or on the command-line when running a container. The modern command-line option for this is the {{{--mount}}} parameter which requires a type, source, and target. The type can be {{{type=bind}}} to use an OS bind mount or {{{type=volume}}} to utilize a docker IO driver.
+
+Examples:
+ - run container with a bind-mount from host {{{/usr/src/}}} to containers {{{/usr/src}}}
+{{{#!bash
+docker run -it --mount type=bind,source=/usr/src,target=/usr/src ubuntu-16.04
+}}}
+ - create a volume and mount it in a container:
+{{{#!bash
+docker volume create ubuntu-16.04
+}}}
+ - run container with a volume mounted from host to {{{/usr/src}}}
+{{{#!bash
+docker run -it --mount type=volume,source=ubuntu-16.04,target=/root/workspace ubuntu-16.04
+}}}
+
+
+Notes:
+ - use '--tmpfs' (ie --tmpfs /run:rw,noexec,nosuid,size=65536k) to mount a tmpfs
+
+
+== Examples
+
+=== Ubuntu 20.04 Focal container
+
+This example shows how to create an Ubuntu 20.04 Focal container from an Ubuntu host OS. The steps will vary a bit on other host Operating Systems.
+
+1. Create a docker 'image' based on Ubuntu 20.04:
+ - On a Linux host, docker images are created from a DockerFile that provides details and commands used to build the image
+{{{#!bash
+mkdir ubuntu-focal
+cat << EOF ubuntu-focal/DockerFile
+# from base image ubuntu 20.04
+FROM ubuntu:20.04
+
+# Disable Prompt During Packages Installation
+ARG DEBIAN_FRONTEND=noninteractive
+
+# update list of available packages
+RUN apt-get update
+
+# add a non-root user
+ARG USER=build
+ARG UID=1000
+ARG GID=1000
+RUN groupadd -g $GID $USER && useradd -g $GID -m -s /bin/bash -u $UID $USER
+
+# and give that user permission to use sudo
+RUN apt-get install sudo
+RUN echo "$USER ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers
+
+# and set the prompt as a reminder 
+RUN echo 'export PS1="\u@focal:\w\$ "' >> /home/$USER/.bashrc
+# switch to this user
+USER $USER
+WORKDIR /home/$USER
+}}}
+ - use the 'docker build' command to build the OS image:
+{{{#!bash
+docker build --tag ubuntu-22.04 --build-arg USER=$USER --build-arg UID=$(id -u) --build-arg GID=$(id -g) ubuntu-jammy/
+}}}
+  * the '--build-arg' options above are optional but show how you can use your host Linux OS user/group to replace the default ones specified in the DockerFile. This can be very useful if you mount a filesystem from your host OS into your container and want to share user permissions
+  * building the 'image' is a one-time operation. You only need to repeat it if you change the DockerFile specifying the image
+  * if wanted you can add additional 'RUN apt-get install -y <packages>' steps before the 'USER $USER' command (which switches the user from root to a non-root user, otherwise you would need to use sudo) to install additional packages so that you don't have to do that every time you create a new container from the image
+1. Create and start docker container
+{{{#!bash
+docker run -it --privileged \
+  --mount type=bind,source=/usr/src,target=/usr/src \
+  --mount type=bind,source=/tftpboot,target=/tftpboot \
+  --name jammy ubuntu-jammy
+}}}
+ * the '--mount' options are optional but show how you can mount directories from your host OS to the container's OS. In this case we have mounted /tftpboot so we can copy files from the container to the hosts's tftpboot directory where a TFTP server may be running. We also mount /usr/src from the host OS to allow our host OS to get to source files we use
+ * Note that once you 'run' a container it remains present even if you have detached from it meaning you can later re-attach to it
+ * The '--it' option is a shortcut for '--interactive' and '--tty' which allocates a pseudo-TTY terminal and keeps STDIN open even if not attached. These options allow the bash process to start in the container, attaches the host OS console to the processes standard input/output/error, and allocates a text-only console.
+
+If you at some point exit your docker container you can attach to it again later with the 'docker attach <containerid>' command after using 'docker container ls' to show available containers.
+
+