Create a container and run it in the background

$ docker run -d -p 80:80 docker/getting-started

• -d - Run the container in detached (background) mode
• -p 80:80 - Map port 80 to port 80 in the container, format: host port: container port
• docker/getting-started - the mirror to use

Create and run the container in the foreground (if you want to exit the container but not close the container, press Ctrl+P+Q)

$ docker run -it --rm -p 8001:8080 --name my-nginx nginx

• -it - Interactive bash mode
• --rm - Automatically delete container files after the container terminates
• -p 8001:8080 - maps 8001the port to 8080the port in the container
• --name my-nginx - specify a name
• nginx - the mirror to use

docker create [options] IMAGE
  -a, --attach # Attach standard output/errors
  -i, --interactive # append standard input (interactive)
  -t, --tty # pseudo-terminal pseudo-tty
      --name NAME # Name your image
  -p, --publish 5000:5000 # Port mapping (host:container)
      --expose 5432 # Expose the port to the container 
  -P, --publish-all # Publish all ports
      --link container:alias # link linking
  -v, --volume `pwd`:/app # mount (absolute path required)
  -e, --env NAME=hello # environment variables env vars

example

$ docker create --name my-container -p 8080:80 nginx

# Build an image from a Dockerfile located in the current directory
docker build -t my-image .

# Build an image from a Dockerfile located in a specific directory
docker build -t my-image /path/to/Dockerfile/directory

# Build an image with a specific tag
docker build -t my-username/my-image:1.0 .

# Build an image with build arguments
docker build -t my-image --build-arg MY_ARG=value .

# Build an image with a custom Dockerfile name
docker build -t my-image -f Dockerfile.custom .

# Build an image from a Dockerfile located in a specific GitHub repository
docker build github.com/creack/docker-firefox

# Build an image from a Dockerfile passed via STDIN
docker build - < Dockerfile

# Build an image from a context passed via STDIN
docker build - < context.tar.gz

# Build an image with a specific tag
docker build -t eon/nginx-server .

# Build an image from a different Dockerfile than the default
docker build -f myOtherDockerfile .

# Build an image from a remote Dockerfile
curl example.com/remote/Dockerfile | docker build -f - .

remove all

$ docker rmi -f $(docker images | grep "none" | awk '{print $3}')

This command will remove all Docker images on your machine that are not currently being used by any containers. Here's how it works:

• docker images lists all Docker images on the host machine.
• grep "none" filters the output to show only images with the tag "none". These images are usually created when a new image is built, and the old image with the same name and tag is still present on the machine.
• awk '{print $3}' extracts the third column from the output, which is the image ID.
• $() is a command substitution that passes the output of the previous command as input to docker rmi -f. The -f option forces the removal of the specified image(s).

docker network create -d overlay OverlayNetwork
docker network create -d bridge BridgeNetwork
docker network create -d overlay \
  --subnet=192.168.0.0/16 \
  --subnet=192.170.0.0/16 \
  --gateway=192.168.0.100 \
  --gateway=192.170.0.100 \
  --ip-range=192.168.1.0/24 \
  --aux-address="my-router=192.168.1.5" \
  --aux-address="my-switch=192.168.1.6" \
  --aux-address="my-printer=192.170.1.5" \
  --aux-address="my-nas=192.170.1.6" \
  OverlayNetwork

• --subnet - Defines one or more subnets for the network.
• --gateway - Defines one or more gateways for the network.
• --ip-range - Defines a range of IP addresses that can be assigned to containers on the network.
• --aux-address - Defines additional IP addresses that can be assigned to containers on the network.

To log in to the mirror warehouse:

docker login
docker login localhost:8080

To log out of the mirror repository:

docker logout
docker logout localhost:8080

To search for a mirrored image:

docker search nginx
docker search nginx --stars=3 --no-trunc busybox

To pull a mirrored image:

docker pull nginx
docker pull eon01/nginx
docker pull localhost:5000/myadmin/nginx

To push a mirrored image:

docker push eon01/nginx
docker push localhost:5000/myadmin/nginx

Note that some of these commands are specific to Docker Swarm mode, which is a feature of Docker that allows you to run Docker in a clustered mode. Other commands, such as the --orchestrator kubernetes option, are specific to deploying Docker stacks to a Kubernetes cluster.

--add-host list # Add a custom host to the IP map (host:ip)
-a, --attach list # Connect to STDIN, STDOUT or STDERR
    --blkio-weight uint16 # block IO (relative weight), between 10 and 1000, or 0 disabled (default 0)
    --blkio-weight-device list # Block IO weights (relative device weights) (default [])
    --cap-add list # Add Linux functions
    --cap-drop list # Drop Linux functions
    --cgroup-parent string # Optional parent cgroup of the container
    --cgroupns string # The Cgroup namespace to use (host|private)
                        # 'host': cgroup namespace of the Docker host to run the container in
                        # 'private': run the container in its own private cgroup namespace
                        # '': use the 
                        # default-cgroupns-mode option (default)
    --cidfile string # Write the container ID to a file
    --cpu-period int # Limit CPU CFS (Completely Fair Scheduler) periods
    --cpu-quota int # Limit CPU CFS (full fair scheduler) quota
    --cpu-rt-period int # Limit CPU real-time cycles in microseconds
    --cpu-rt-runtime int # Limit CPU realtime runtime in microseconds
-c, --cpu-shares int # CPU shares (relative weights)
    --cpus decimal # Number of CPUs
    --cpuset-cpus string # CPUs allowed to execute (0-3, 0,1)
    --cpuset-mems string # MEMs allowed to execute (0-3, 0,1)
    --device list # Add the host device to the container
    --device-cgroup-rule list # Add the rule to the list of devices allowed by the cgroup
    --device-read-bps list # Limit the read rate (bytes per second) of the device (default [])
    --device-read-iops list # Limit the read rate (IOs per second) of the device (default [])
    --device-write-bps list # Limit the write rate of the device (bytes per second) (default [])
    --device-write-iops list # Limit the write rate of the device (IO per second) (default [])
    --disable-content-trust # Skip image verification (default true)
    --dns list # Set custom DNS servers
    --dns-option list # Set DNS options
    --dns-search list # Set custom DNS search domains
    --domainname string # Container NIS domain name
    --entrypoint string # Override the default entry point of the mirror
--e, --env list # Set environment variables
    --env-file list # Read in environment variable files
    --expose list # expose a port or series of ports
    --gpus gpu-request # GPU devices to add to the container ("all" to pass all GPUs)
    --group-add list # Add other groups to join
    --health-cmd string # Command to run to check operational status
    --health-interval duration # Time (ms|s|m|h) between run checks (default 0s)
    --health-retries int # Need to report unhealthy consecutive failures
    --health-start-period duration # Start time (ms|s|m|h) for container initialization before starting the health retry countdown (default 0s)
    --health-timeout duration # The maximum time (ms|s|m|h) allowed to run a check (default 0s)
    --help # Print the use of
-h, --hostname string # The container host name
    --init # Run an init inside the container to forward signals and harvest processes
--i, --interactive # Keep STDIN open even if there is no connection
    --ip string # IPv4 address (e.g. 172.30.100.104)
    --ip6 string # IPv6 address (e.g., 2001:db8::33)
    --ipc string # The IPC mode to use
    --isolation string # Container isolation technology
    --kernel-memory bytes # Kernel memory limit
-l, --label list # Set metadata on the container
    --label-file list # Read in line delimited label files
    --link list # Add a link to another container
    --link-local-ip list # container IPv4/IPv6 link local address
    --log-driver string # The container's logging driver
    --log-opt list # Logging driver options
    --mac-address string # MAC address of the container (e.g. 92:d0:c6:0a:29:33)
-m, --memory bytes # Memory limit
    --memory-reservation bytes # Memory soft limit
    --memory-swap bytes # Swap limit equal to memory plus swap: '-1' Enable unlimited swap
    --memory-swappiness int # Adjust container memory swapping (0 to 100) (default -1)
    --mount mount # Attach a filesystem mount to the container
    --name string # Assign a name to the container
    --network network # Connect the container to the network
    --network-alias list # Add network-wide aliases to the container
    --no-healthcheck # Disable any container-assigned HEALTHCHECK
    --oom-kill-disable # Disable OOM killers
    --oom-score-adj int # Adjust the host's OOM preferences (-1000 to 1000)
    --pid string # The PID namespace to use
    --pids-limit int # Adjust container pids limit (set -1 for no limit)
    --platform string # Set the platform if the server supports multiple platforms
    --privileged # Grant extended privileges to this container
-p, --publish list # Publish the container's ports to the host
-P, --publish-all # Publish all exposed ports to random ports
    --pull string # Pull mirrors ("always"|"missing"|"never") before creation (default "missing")
    --read-only # Mount the container's root filesystem as read-only
    --restart string # Restart policy to apply when the container exits (default "no")
    --rm # Automatically remove the container when it exits
    --runtime string # Runtime for this container
    --security-opt list # Security options
    --shm-size bytes # size of /dev/shm
    --stop-signal string # Signal to stop the container (default "SIGTERM")
    --stop-timeout int # Timeout to stop the container (in seconds)
    --storage-opt list # Storage driver options for the container
    --sysctl map # Sysctl options (default map[])
    --tmpfs list # Mount tmpfs directory
-t, --tty # Assign a pseudo TTY
    --ulimit ulimit # ulimit option (default [])
--u, --user string # Username or UID (format: <name|uid>[:<group|gid>])
    --userns string # The user namespace to use
    --uts string # The UTS namespace to use
--v, --volume list # Bind the mounted volumes
    --volume-driver string # Optional volume driver for the container
    --volumes-from list # Mount volumes from the specified container
-w, --workdir string # The working directory inside the container

--config path                 Location of client config files (default "~/.docker")
--context string              Name of the context to use to connect to the daemon (overrides DOCKER_HOST env var and default context set with "docker context use")
  -c, --context string        Alias for --context
  -D, --debug                 Enable debug mode
  -H, --host list             Daemon socket(s) to connect to
  -l, --log-level string      Set the logging level ("debug", "info", "warn", "error", "fatal") (default "info")
      --tls                   Use TLS; implied by --tlsverify
      --tlscacert string      Trust certs signed only by this CA (default "~/.docker/ca.pem")
      --tlscert string        Path to TLS certificate file (default "~/.docker/cert.pem")
      --tlskey string         Path to TLS key file (default "~/.docker/key.pem")
      --tlsverify             Use TLS and verify the remote
  -v, --version               Print version information and quit

$ docker volume create portainer_data
$ docker run -d -p 8000:8000 -p 9000:9000 --name portainer --restart always -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer-ce

• This will create a Docker volume for Portainer's data and start the Portainer container, exposing ports 8000 and 9000 for web access and mapping the Docker daemon's socket to the container.
• Once the Portainer container is running, you can access the web interface by navigating to http://localhost:9000 in your web browser.

You will be prompted to create an initial administrator account. Once you have done that, you can start managing your Docker environment through Portainer's web interface.

Portainer provides a graphical user interface that allows you to manage your Docker containers, images, volumes, and networks and manage users, teams, and roles. For example, you can easily create and deploy new containers, inspect and manage existing containers, view logs and resource usage, and perform container backups and restores.

First, you need to create a Dockerfile to build the Code Server image:

FROM codercom/code-server:latest
USER root
RUN apt-get update && \
    apt-get install -y build-essential && \
    apt-get clean
USER coder

This Dockerfile uses the latest version of the Code Server image and installs the build-essential package for compiling and building code. It also sets the user to coder to avoid running Code Server as the root user.

Once you have created the Dockerfile, you can build the Code Server image using the docker build command:

$ docker build -t my-code-server .

This will build the image and tag it with the name my-code-server.

Once the image is built, you can start a new container by running the following command:

$ docker run -it -p 127.0.0.1:8080:8080 my-code-server

Code Server provides a full-featured code editor that supports multiple programming languages and extensions. You can create and edit files, run code, debug, and even collaborate with others in real-time.

$ docker run --name mysql \
  -p 3306:3306 \
  -v $HOME/mysql/conf.d:/etc/mysql/conf.d \
  -v $HOME/mysql/data:/var/lib/mysql \
  -v /etc/localtime:/etc/localtime:gb \
  -e MYSQL_ROOT_PASSWORD=54321 \
  -d mysql:5.8.23

$ docker run -d --name myredis \
  -v $HOME/redis/conf:/usr/local/etc/redis \
  -v /etc/localtime:/etc/localtime:gb \
    redis redis-server /usr/local/etc/redis/redis.conf

$ docker run --name my-nginx \ 
  -v "$HOME/nginx/nginx.conf:/etc/nginx/nginx.conf:ro" \
  -v "$HOME/nginx/html:/usr/share/nginx/html:ro" \
  -p 8080:80 \
  -d nginx

$ docker run --name my-postgres \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -e PGDATA=/var/lib/postgresql/data/pgdata \
  -v $HOME/nginx/mount:/var/lib/postgresql/data \
  -d postgres

$ docker run --name my-dim \
   -p 8000:8000/tcp \
   -v $HOME/.config/dim:/opt/dim/config \
   -v $HOME/dim/media:/media:ro \
   -d ghcr.io/dusk-labs/dim:dev

$ docker run -d --name gitlab \
  --hostname gitlab.example.com \
  --publish 8443:443 --publish 8081:80 -p 2222:22 \
  --restart always \
  --volume $HOME/gitlab/config:/etc/gitlab \
  --volume $HOME/gitlab/logs:/var/log/gitlab \
  --volume $HOME/gitlab/data:/var/opt/gitlab \
  -v /etc/localtime:/etc/localtime \
  --shm-size 256m \
    gitlab/gitlab-ce:latest