Рубрика: docker

Ссылки:

https://selectel.ru/blog/what-is-docker/
https://habr.com/ru/company/timeweb/blog/594533/

https://github.com/amatiashov/YT-Docker-lesson

Вводное:

Контейнеры — это способ упаковать приложение и все его зависимости в единый образ. 
Этот образ запускается в изолированной среде, не влияющей на основную операционную систему. 
Контейнеры позволяют отделить приложение от инфраструктуры: разработчикам не нужно задумываться, 
в каком окружении будет работать их приложение, будут ли там нужные настройки и зависимости. 
Они просто создают приложение, упаковывают все зависимости и настройки в единый образ. 
Затем этот образ можно запускать на других системах, не беспокоясь, что приложение не запустится.

Docker — это платформа для разработки, доставки и запуска контейнерных приложений. 
Docker позволяет создавать контейнеры, автоматизировать их запуск и развертывание, управляет жизненным циклом. 
Он позволяет запускать множество контейнеров на одной хост-машине.

Контейнеризация похоже на виртуализацию, но это не одно и то же. 
Виртуализация работает как отдельный компьютер, со своим виртуальным оборудованием и операционной системой. 
При этом внутри одной ОС можно запустить другую ОС. 
В случае контейнеризации виртуальная среда запускается прямо из ядра основной операционной системы и не виртуализирует оборудование. 
Это означает, что контейнер может работать только в той же ОС, что и основная. 
АПри этом так как контейнеры не виртуализируют оборудование, они потребляют намного меньше ресурсов.


Docker:
Решает проблемы зависимостей и рабочего окружения.
Изоляция и безопасность.
Ускорение и автоматизация развертывания приложений и масштабируемость.
Контейнеры приближают к микросервисной архитектуре(приложение не монолитно).
Docker compose — одновременно развернуть несколько контейнеров.
Хранение данных в Docker.

Хранение данных в Docker.

Эфемерность. Это означает, что контейнеры могут быть в любой момент остановлены, перезапущены или уничтожены. 
При этом все накопленные данные в контейнере будут потеряны. 
Поэтому приложения нужно разрабатывать так, чтобы они не полагались на хранилище данных в контейнере, это называется принципом Stateless.
Это хорошо подходит для приложений или сервисов, которые не сохраняют результаты своей работы. 
Например, функции расчета или преобразования данных: им на вход поступил один набор данных, они его преобразовали или рассчитали и вернули результат. 
Все, ничего никуда сохранять не нужно.
Но далеко не все приложения такие, и есть много данных, которые нужно сохранить. 
В контейнерах для этого предусмотрены несколько способов.

Тома (Docker volumes)
Это способ, при котором докер сам создает директории для хранения данных. 
Их можно сделать доступными для разных контейнеров, чтобы они могли обмениваться данными. 
По умолчанию эти директории создаются на хост-машине, но можно использовать и удаленные хранилища: 
файловый сервер или объектное хранилище.

Монтирование каталога (bind mount)
В этом случае директория сначала создается в хост-системе, а уже потом монтируется в докер контейнеры.
Но этот способ не рекомендуется, потому что он усложняет резервное копирование, 
миграцию и совместное использование данных несколькими контейнерами.

Docker daemon

Это сервис, через который осуществляется все взаимодействие с контейнерами: 
создание и удаление, запуск и остановка. 
Этот сервис работает в фоновом режиме и получает команды от интерфейса командной строки или API.

Docker client (клиент)

Это интерфейс командной строки для управления docker daemon.
Мы пользуемся этим клиентом, когда создаем и разворачиваем контейнеры, а клиент отправляет эти запросы в docker daemon.

Docker image (образ)

Это неизменяемый файл (образ), из которого разворачиваются контейнеры. 
Приложения упаковываются именно в образы, из которых потом уже создаются контейнеры.
Приведем аналогию на примере установки операционной системы. 
В дистрибутиве (образе) ОС есть все, что необходимо для ее установки. 
Но этот образ нельзя запустить, для начала его нужно «развернуть» в готовую ОС. 
Так вот, дистрибутив для установки ОС — это Docker image, а установленная и работающая ОС — это Docker container.
Но контейнеры обычно разворачиваются одной командой — это намного проще и быстрее, чем установка ОС.

Docker container (контейнер)

Это уже развернутое из образа и работающее приложение.

Docker Registry

Это репозиторий с докер-образами. 
Разработчики создают образы своих программ и выкладывают их в репозиторий, чтобы их можно было скачать и воспользоваться ими. 
Распространенный публичный репозиторий — Docker Hub. В нем собраны образы множества популярных программ или платформ: 
базы данных, веб-серверы, компиляторы, операционные системы и так далее. 
Также можно создать свой приватный репозиторий, например внутри компании. 
Разработчики будут размещать там образы, которые будут использоваться всей компанией.

Dockerfile

Dockerfile — это инструкция для сборки образа. 
Это простой текстовый файл, содержащий по одной команде в каждой строке. 
В нем указываются все программы, зависимости и образы, которые нужны для разворачивания образа.

Пример Dockerfile

FROM python:3 
COPY main.py /
CMD [ "python", "./main.py" ]

Первая строчка означает, что за основу мы берем образ с названием python версии 3 это называется базовый образ. 
Docker найдет его в docker registry, скачает и будет использовать за основу. 
Вторая строчка означает, что нужно скопировать файл main.py в корень файловой системы контейнера. 
Третья строчка означает, что нужно запустить python и передать ему в качестве параметра название файла main.py

Все эти команды выполняются в Docker client, который отправляет их в docker daemon:

Команда docker build (зеленая) читает dockerfile и собирает образ.

Команда docker pull (красная) скачивает образ из docker registry. 
                    По умолчанию docker скачивает образы из публичного репозитория Docker Hub. 
                    Но можно создать свой репозиторий и настроить докер, чтобы он работал с ним.

Команда docker run (черная) берет образ и разворачивает его в контейнер.

Установка Docker на debian\ubuntu:

Cинхронизируем пакетную базу apt и установим нужные зависимости:
sudo apt-get update
sudo apt-get install apt-transport-https ca-certificates curl gnupg lsb-release

Импортируем GPG-ключ для репозитория docker:
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Добавим новый репозиторий в список apt:
echo \
  "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null


Установим докер:
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io

По умолчанию, доступ к docker daemon есть только у пользователя root. 
Чтобы с докером могли работать и другие пользователи, их нужно добавить в специальную группу — docker. 
Выполните эту команду из под обычного пользователя:
sudo usermod -aG docker $USER
После этого необходимо перелогиниться, чтобы изменение вступило в силу.

Запуск контейнера

Попробуем запустить какое-нибудь готовое приложение. 
Выполните команду:
docker run ubuntu echo 'hello from ubuntu'

Команда docker run создает и запускает контейнер из образа. 
В этом примере мы создаем контейнер из образа ubuntu, затем выполняем в нем команду echo ‘hello from ubuntu’. 
Но так как у нас чистая установка докера и мы не скачали ни одного образа, докер сначала найдет этот образ в публичном репозитории Docker Hub, скачает, а потом создаст из него контейнер. 
В следующий раз, когда нам понадобится образ ubuntu, докер уже не будет его скачивать.
После выполнения команды в терминале появится строка hello from ubuntu, и контейнер сразу остановится. 

Теперь выполним другую команду:
docker run -it ubuntu
Эта команда запустит контейнер в интерактивном режиме, то есть контейнер запустится и будет ждать дальнейших команд. 
При этом мы окажемся внутри операционной системы контейнера: 
запустится оболочка (bash), и мы сможем выполнять какие-то команды внутри контейнера. 
Чтобы выйти из контейнера, введите команду exit.

Создание собственного образа и запуск контейнера

Теперь создадим HelloWorld-приложение на Python, обернем его в образ и запустим.
Cоздадим директорию, в которой мы будем работать и перейдем в нее:
mkdir first-docker-app
cd first-docker-app

Создадим файл main.py и запишем в него одну строчку кода:
echo 'print("Hello from python");' >> main.py

Проверим, что наша программа работает(В консоли должно выйти сообщение "Hello from python"):
python main.py

Теперь нужно обернуть его в докер-образ. 
Для этого создадим файл Dockerfile и напишем в нем три строчки:
vim Dockerfile
--------------
FROM python:3
COPY main.py /
CMD [ "python", "./main.py" ]
--------------

В первой строке мы указываем образ, который берем за основу. 
Так как мы пишем приложение на Python, нужно чтобы в нашем образе он уже был установлен. 
Самый простой способ это сделать — использовать готовый официальный образ с Docker Hub. 
Цифра 3 — это тег. Он означает, что нужно использовать третью версию Python. 
Вместо этого можно было бы использовать тег latest, который означает самую последнюю версию, 
или можно было указать номер конкретной версии, например 3.8.8.
Во второй строчке мы копируем наш файл main.py в корневую директорию образа.
Третья строчка — запускаем python и передаем ему в качестве параметра имя нашего файла

Теперь из этого докер-файла можно собирать образ:
!!! Параметр -t обозначает имя нашего образа, мы назвали его first-docker-app.
docker build -t first-docker-app .

Проверим список установленных у нас образов:
docker images

Теперь создадим контейнер из нашего образа и запустим его:
docker run first-docker-app

Список полезных команд docker:

Посмотреть список всех контейнеров:
docker ps -a

Остановить  все докер контейнеры:
docker stop $(docker ps -a -q)

Удалить все докер контейнеры:
docker rm $(docker ps -a -q)

Запустить контейнер с последующим удалением:
docker run --rm ubuntu echo 'hello from ubuntu'

Посмотреть список всех скачанных образов:
docker images

Удалить докер образ(перед удаление требуется остановить):
docker rmi name_image

Чтобы принудительно удалить образ, добавьте флаг -f:
docker rmi -f name_image

Что бы удалить все образы
docker rmi $(docker images -q)

Получить список всех контейнеров, созданных из определенного образа:
docker ps -a --filter ancestor=name_image

Еще раз для тех кто в танке, напримере python образа и нашего приложения:

!!! apt install docker docker.io
!!! Запоминаем что задача докер это выполнить приложение (ну тоесть поработали и если работы нет, закончили)
0. Создаем папку testfile в каталоге opt и переходим в нее
mkdir /opt/testfile
cd /opt/testfile

1. Создаем файл нашего приложения:
vim app.py
---------- 
print("Hello, world")
----------

2. Создаем Dockerfile:
vim Dockerfile
-------------- 
FROM python:3.6  # используем образ python 3.6
RUN mkdir -p /usr/src/app/ # создаем каталог  /usr/src/app/ 
WORKDIR /usr/src/app/ # указываем рабочий каталог
COPY . /usr/src/app/ # копируем файлы из текущего домашнего каталога в контейнер
CMD ["python", "app.py"] # собственно ради чего мы тут собрались, выполняем наше приложение app.py
-------------- 

3. Производим сборку контейнера из текущего каталога и наш контейнер называем hellow-world
cd /opt/testfile
docker build -t hellow-world . 

4. Проверяем что у нас там собралось:
docker images

5. Запускаем наш контейнер:
docker run hellow-world 

6. После когда наш контейнер отработал мы можем выполнить запуск нашего контейнера уже под другим именем например hello
docker run --name hello hellow-world

7. Посмотреть все отработанные контейнеры и их статус можно командой
docker ps -a 

8. Удаление контейнера
docker rm ID-контейнера

9. Когда у вас например 50 контейнеров удаление может затянутся, "docker ps" умеет выводить ID контейнеров
docker ps -a -q
docker rm $(docker ps -qa)

 

Пример приложения работающего подольше \ бесконечно и запуск его в режиме демона:

0. Редактируем наше приложение:
vim app.py
----------
import time

while True:
      print("hello, World!")
      time.sleep(1)
----------

1. Производим сборку контейнера и запуск (-d запускает контейнер в режиме демона)
docker build -t hello2 . 
docker run --name hello2 -d hello2

2. Проверяем что там у нас работает:
docker ps -a 

3. Для остановки контейнера выполним следующие
docker stop hello2

4. Для запуска контейнера с дальнейшим удалением  после остановки выполнения (docker stop)
docker run --name hello2 -d --rm hello2

Пошли дальше чуть посложнее web приложение:

0. Готовим приложение, создаем каталог, переходим в него и создаем первый файл app.py
mkdir /opt/webp
cd /opt/webp

vim app.py
----------
import os
import json
import datetime
from flask import Flask

app = Flask(__name__)

BASE_FOLDER = os.path.dirname(os.path.abspath(__file__))
RESOURCE_DIR = os.path.join(BASE_FOLDER, "resources")


@app.route('/')
def hello_world():
    with open(os.path.join(RESOURCE_DIR, "response.json")) as f:
        return "%s - %s" % (json.loads(f.read()).get("payload"), datetime.datetime.now().strftime("%d.%m.%Y %H:%M:%S"))


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8080, debug=True)
------------


1. Готовим Докер файл
vim Dockerfile
--------------
FROM python:3.6 # используем образ python3.6
RUN mkdir -p /usr/src/app/ # создаем каталог в контейнере
WORKDIR /usr/src/app/ # указываем рабочий каталог нашего приложения
COPY . /usr/src/app/ # копируем локальные файлы в контейнер
RUN pip install --no-cache-dir -r requirements.txt # устанавливаем зависимости для python
EXPOSE 8080 #нехрена не пробросит, наши пожелания что мы хотели бы пробросить порт, при запуске укажем что нам нужно
#ENV TZ Europe/Moscow # передаем значение переменно окружения для отображения правильного времени, это можно передать при запуске контейнера
CMD ["python", "app.py"] # выполняем наше приложение
--------------

2. Готовим requirements.txt, файл зависимостей
!!! Если бы без docker для python запуска можно было бы просто выполнить "pip install -r requirements.txt"
vim requirements.txt
--------------------
flask==1.1.1
--------------------

4. Готовим файл с ресурсами 
mkdir resource
vim response.json
-----------------
{
    "payload": "Hello, World!!!."
}
-----------------

5. Собираем контейнер:
docker build -t web-hello . 
docker images 

6. Запуск контейнера и пробрасываем порты:
docker run -d --rm --name web -p 8080:8080 web-hello

7. Передача переменной TZ в контейнер и запуск контейнера:
docker run -d --rm --name web -p 8080:8080 -e TZ=Europe/Moscow web-hello

8. Монтирование локального каталога в докер (!!! Сейчас этот способ менее популярен)
docker run --name hello4 --rm  -p 8080:8080 -v /opt/web-hello/resources:/usr/src/app/resources  web-hello
run - запускаем контейнер
--name hello4 - желаемое имя контейнера
--rm - в случае остановки удалить контейнер
-p 8080:8080 - желаем пробросить порт 8080
-v /opt/web-hello/resources:/usr/src/app/resources - пробросить локальную_папку:в_контейнер
web-hello имя используемого образа для контейнера

9. Использование docker volume
docker volume ls - посмотреть какие доступны виртуальные разделы
docker volume create web - создаем раздел web

Работа с mongodb и введение использование volume

0. Готовим директорию
!!! для локального теста нужно установить pip install pymongo storage  uuid
mkdir /opt/testdb
cd /opt/testdb

1. Создаем файл app.py
----------------------
cat > app.py << "EOF"
import time
from uuid import uuid4
from storage import MongodbService

storage = MongodbService.get_instance()

for _ in range(5):
    dto = {
        "_id": str(uuid4()),
        "payload": str(uuid4()),
        "field2": str(int(time.time()))
    }
    storage.save_data(dto)


for data in storage.get_data():
    print(data)
EOF
----------------------

2. Создаем файл storage.py 
--------------------------
cat > storage.py  << "EOF"
from pymongo import MongoClient
class MongodbService(object):
    _instance = None
    _client = None
    _db = None

    @classmethod
    def get_instance(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls, *args, **kwargs)
            cls.__init__(cls._instance, *args, **kwargs)
        return cls._instance

    def __init__(self):
        self._client = MongoClient("localhost", 27017)
        self._db = self._client.youtube_db

    def get_data(self):
        return list(self._db.statistics.find())

    def save_data(self, dto):
        return self._db.statistics.insert_one(dto)
EOF
--------------------------

3. Запуск mongo
docker run --rm -d -p 27017:27017 mongo

4. Тестирование нашего приложения
python app.py - будут добавляется данные в базу данных

5. при остановке контейнера данные бд будут удалены
!!! ВНИМАНИЕ НАКОПЛЕННЫЕ ДАННЫЕ БД УДАЛЯТСЯ
docker stop id-mongo

Docker-compose

0. перешли в каталог куда мы скачали docker-compose
1. запустили на выполнение
docker-compose up -d
2. Посмотрели что там 
docker ps -a 
3. Надоело остановили работу
docker-compose down 

Docker-hub push

0. Перешли в каталог с файлами для сборки
1. Выполняем сборку 
docker build -t Ваш_логин_доке_хаб/имя_приложения .
2. Заливаем образ на докер хаб
docker push -t  Ваш_логин_доке_хаб/имя_приложения

Информация:

Docker - это средство упаковки, доставки и запуска приложения.

https://www.docker.com/ - оф сайт
https://habr.com/ru/post/277699/ - введение
https://www.8host.com/blog/ustanovka-i-ispolzovanie-docker-v-debian-9/ - установка и инструкция
https://linux-notes.org/rabota-s-setju-networking-v-docker/  - установка и инструкция
https://sysadmin.ru/articles/ustanovka-docker-v-linux - установка и инструкция
https://docs.docker.com/docker-for-windows/install/ - установка на windows
https://docs.docker.com/docker-for-mac/install/ - установка на MACOS
https://habr.com/ru/post/277699/

https://www.digitalocean.com/community/tutorials/docker-ru - хороший гайд для новичков

Установка:

Ставить будем на debian 11
apt install docker docker-compose

Основные команды кратко:

# справочная информация
docker --help # список доступных команд
docker  --help # информация по команде
 
docker --version # версия Docker
docker info # общая информация о системе
 
# работа с образами
docker search debian # поиск образов по ключевому слову debian
 
docker pull ubuntu # скачивание последней версии (тег по умолчанию latest) официального образа ubuntu (издатель не указывается) из репозитория по умолчанию docker.io/library
docker pull prom/prometheus # скачивание последней версии (latest) образа prometheus от издателя prom из репозитория docker.io/prom
docker pull docker.io/library/ubuntu:18.04 # скачивание из репозитория docker.io официального образа ubuntu с тегом 18.04
 
docker images # просмотр локальных образов
 
docker rmi : # удаление образа. Вместо : можно указать . 
                              # Для удаления образа все контейнеры на его основе должны быть как минимум остановлены
docker rmi $(docker images -aq) # удаление всех образов
 
# работа с контейнерами
docker run hello-world # Hello, world! в мире контейнеров
docker run -it ubuntu bash # запуск контейнера ubuntu и выполнение команды bash в интерактивном режиме
docker run --name docker-getting-started --publish 8080:80 docker/getting-started # запуск контейнера gettind-started с отображением (маппингом) порта 8080 хоста на порт 80 внутрь контейнера
docker run --detach --name mongodb docker.io/library/mongo:4.4.10 # запуск контейнера mongodb с именем mongodb в фоновом режиме. Данные будут удалены при удалении контейнера!
 
docker ps # просмотр запущенных контейнеров
docker ps -a # просмотр всех контейнеров (в том числе остановленных)
docker stats --no-stream # просмотр статистики
 
docker start alpine # создание контейнера из образа alpine
 
docker start  # запуск созданного контейнера. Вместо  можно указать 
docker start $(docker ps -a -q) # запуск всех созданных контейнеров
 
docker stop  # остановка контейнера. Вместо  можно указать 
docker stop $(docker ps -a -q) # остановка всех контейнеров
 
docker rm  # удаление контейнера. Вместо  можно указать 
docker rm $(docker ps -a -q) # удаление всех контейнеров
 
# система
docker system info # общая информация о системе (соответствует docker info)
docker system df # занятое место на диске
docker system prune -af # удаление неиспользуемых данных и очистка диска

Основные команды подробней:

### https://hub.docker.com/ - тут ищем контейнеры

docker --help - помощь
docker ps - показать бегущие контейнеры
docker ps --all  - показать бегущие контейнеры и остановленные

Загрузка:
docker image ls - показать загруженные образы контейнеров
docker image pull nginx:1.20.1-alpine - скачать контейнер nginx:1.20.1-alpine
docker image pull nginx - скачать контейнер nginx, будет скачан самый последний образ

Запуск:
docker run \
--name nginx \
-v /srv/nginx/:/usr/share/nginx/html \
-p 80:80 \
-d nginx

Запуск:
docker run nginx:1.18 - запуск контейнера nginx:1.18, контейнер будет запущен в текущей консоли
docker run -p 7777:80 nginx - запуск контейнера nginx,
docker run -d -p 7777:80 nginx - запуск в режиме демона 
docker run -d --rm --name nginx -p 8888:80 nginx:1.18 - опция (--rm) говорит о том что при завершение контейнера он будет удален



Подключение:
docker ps -a
docker exec -it ID_CONTEINER bash - подключится к контейнеру ID_CONTEINER, используем bash внутри контейнера
docker exec -it ID_CONTEINER sh - подключится к контейнеру ID_CONTEINER, используем sh внутри контейнера
docker exec -it 263d85d77e14 bash
docker exec -it 263d85d77e14 sh

Информация:
docker ps -a 
docker inspect ID_CONTEINER
docker inspect 2a420e4ceb84
ps - uax |grep docker


Логи:
docker ps -a 
docker logs -f ID_CONTEINER
docker logs -f 12622b1bd1a8


Отключение и удаление контейнеров:
docker ps -a
docker stop ID_CONTEINER
docker rm ID_CONTEINER

Отключение и удаление всех контейнеров:
docker ps -a | awk '{print $1}'
docker stop $(docker ps -a | awk '{print $1}')
docker rm $(docker ps -a | awk '{print $1}')


Docker compose:
mkdir test-docker - создали каталог
cd test-docker/ - перешли в каталог 
vim test.yaml - отредактировали
docker-compose up -d - запуск в режиме демона
docker-compose down - выключить 

Пример создания своего контейнера с python:

0. Создали директорию test0
mkdir test0
cd test0
1. Создали файл app.py 
cat > app.py << "EOF"
print("Hello, World!")
EOF

2. Создали файл Dockerfile
cat > Dockerfile << "EOF"
FROM python:3.6

RUN mkdir -p /usr/src/app/
WORKDIR /usr/src/app/

COPY . /usr/src/app/

CMD ["python", "app.py"]
EOF

3. Выполнили сборку контейнера:
docker build -t hellow-world .

docker пример запуска mariadb + adminer

Скачиваем образ mariadb:
docker pull mariadb 
Смотрим доступные образы:
docker images
Запускаем контейнер  mariadb с параметрами:
-d - запуск в режиме демона
-p - проброс портов
-name - имя контейнера
docker run -p 127.0.0.1:3306:3306 --name mariadb -e MARIADB_ROOT_PASSWORD=superoass -d mariaddb
Проверяем что там запустилось: 
docker ps 
Запускаем контейнер adminer:
--link - просим докер добавить запись в /etc/hosts
docker run --name adminer --link mariadb:db -p 8080:8080 -d adminer
Подключаемся к контейнер:
-ti - команда t термина, команда i не отпускать терминал
docker exec -ti adminer sh
Cмотрим что там у нас в /etc/hosts:
cat /etc/hosts

docker stop
docker rm
docker rmi

Dockerfile

vim Dockerfile
--------------------
# syntax=docker/dockerfile:1
FROM ubuntu:18.04
COPY . /app
RUN make /app
CMD python /app/app.py
---------------------

docker build -f /path/to/a/Dockerfile

dockerfile from python

FROM python

dockerfile from apline + python + 8 слоев

FROM apline

RUN apk add --update-cache
RUN apk add python3
RUN apk add pyhton3-dev
RUN apk add py-pip
RUN apk add build-base
RUN pip install virtualenv
RUN rm -rf /var/cache/apk/*

dockerfile from apline + python + уменьшаем кол-во слоев (2 слоя)

FROM apline

RUN apk add --update-cache \
    python3 \
    pyhton3-dev \
    py-pip \
    build-base \
    && pip install virtualenv \
    && rm -rf /var/cache/apk/*

dockerfile from golang:alpine

FROM golang:apline AS builder

WORKDIR /src

COPY go.mod .
COPY go.sum .

RUN go mod download

COPY main.go

FROM alpine:3.15

WORKDIR /app

COPY --from=bulder /src/hello-docker /app/hello-docker

ENTRYPOINT ["/app/hello-docker"]

Docker compose:

mkdir test-docker - создали каталог
cd test-docker/ - перешли в каталог 
vim test.yaml - отредактировали
-------------------------------------
version: "2.2"

services:
  db:
    image: mysql:5.7
    volumes:
      - db_data:/var/lib/mysql
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: somewordpress
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: wordpress

  wordpress:
    depends_on:
      - db
    image: wordpress:latest
    volumes:
      - wordpress_data:/var/www/html
    ports:
      - "8000:80"
    restart: always
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: wordpress
      WORDPRESS_DB_NAME: wordpress
volumes:
  db_data: {}
  wordpress_data: {}
-------------------------------------
docker-compose up - запустится, ctrl+с прервет выполнение
docker-compose up -d - запустить в режиме демона
docker-compose down - выключить 

!!! Внимание
docker-compose down --volumes - удалит еще и данные контейнера

Чем docker не является

Docker часто путают с Vagrant’ом или OpenVZ, или даже VirtualBox’ом. 
Docker это всего-лишь user-space демон на языке Go, который умело жонглирует уже существующими технологиями ядра Linux. 

Не вагрант
Вагрант занимается тем, что управляет виртуальными машинами (или, более приближенно к теме хостинга, виртуальными серверами). 
Так же как и у docker'а, у вагранта есть целая библиотека образов виртуальных машин, и он как и docker умеет их снепшотить, скачивать и заливать, настраивать и запускать. 
Vagrant управляет полноценными тяжелыми виртуальными машинами запущенными, например, в VirtualBox, VMWare, DigitalOcean, AWS, да где только он их не запускает. 
Шикарная вещь, этот вагрант, если вам нужна полноценная виртуальная машина с состоянием внутри.


Не виртуальная машина
И конечно, docker вовсе не является новой технологией (пара)виртуализации, как например KVM/Qemu, VirtualBox/VMWare/Parallels, XEN, etc. 
Docker-демон (не путать с консольной командой docker) работает только в Линуксе (и скоро в винде) поверх линуксовых же контейнеров. 
А контейнеры, в свою очередь, не являются полноценной виртуальной средой, так как они делят общее запущенное ядро одной физической машины. 

Docker состоит из трех частей:
Docker daemon
Docker
Docker Hub

Docker daemon:

docker daemon — сердце docker'а. 
Это демон работающий на хост-машине и умеющий скачивать и заливать образы, запускать из них контейнеры, 
следить за запущенными контейнерами, собирать логи и настраивать сеть между контейнерами (а с версии 0.8 и между машинами). 
А еще именно демон создает образы контейнеров, хоть и может показаться, что это делает docker-client.

Docker

docker это консольная утилита для управления docker-демоном по HTTP. 
Она устроена очень просто и работает предельно быстро. 
Вопреки заблуждению, управлять демоном docker'а можно откуда угодно, а не только с той же машины. 
В сборке нового образа консольная утилита docker принимает пассивное участие: 
архивирует локальную папку в tar.gz и передает по сети docker-daemon, который и делает всё работу. 
Именно из-за передачи контекста демону по сети лучше собирать тяжелые образы локально.

Docker Hub:

Docker Hub централизованно хранит образы контейнеров. 
Когда вы пишете docker run ruby docker скачивает самый свежий образ с руби именно из публичного репозитория. 
Изначально хаба не было, его добавили уже после очевидного успеха первых двух частей.

Установка:

apt update - обновляем список пакетов
apt upgrade - обновляем пакеты
apt install apt-transport-https ca-certificates curl gnupg2 software-properties-common - устанавливаем пакеты
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add -
add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/debian $(lsb_release -cs) stable" - добавляем репозиторий
apt update - обновляем список пакетов
apt-cache policy docker-ce - проверяем доступность пакетов docker
apt install docker-ce - устанавливаем docker
sudo systemctl status docker - проверяем что docker запущен

Добавление пользователя в группу docker:

usermod -aG docker user_name

Добавление пользователя в группу docker:

$ sudo usermod -aG docker ${USER} - добавить текущего пользователя
$ su - ${USER}
$ id -nG - проверить

docker первые шаги после установки

docker info - общая информация 
docker run hello-world - первая команда которой обычно проверяют успешность установки docker
docker search ubuntu - поиск образов ubuntu
docker images - показать установленные образы


docker ps -a - показать все контейнеры
docker start ID_контейнера
docker stop ID_контейнера


Проверяем что у нас установлено:
https://hub.docker.com/ - репозиторий
sudo docker version - посмотреть версию докера
sudo docker login - выполняем авторизацию на докер
sudo docker images - посмотреть установленные образы
sudo docker ps -a - посмотреть что сейчас выполняется в докер

Еще пример:
docker run -it -p 8080:80 yeasy/simple-web
Флаг -i необходим, чтобы контейнер запустился в интерактивном режиме.
Флаг -t необходим для переноса ввода и вывода в контейнер, то есть если мы используем флаг -t для запуска контейнера мы окажемся внутри него.
Флаг -p создает проброс портов между нашим устройством и контейнером, это необходимо для доступа к сети контейнера. 
В нашем случае для доступа к 80 порту внутри контейнера необходимо обратиться к 8080 порту на нашем устройстве.

docker ps -a - посмотрим какие у нас сейчас есть контейнеры
docker stop   - остановка контейнера 
docker start  - запуск контейнера 
docker rm  - удаление контейнера 

docker help:

attach - Присоедините локальные стандартные потоки ввода, вывода и ошибок к работающему контейнеру
build - Создать образ из Dockerfile
commit - Создать новый образ из изменений контейнера
cp - Копировать файлы / папки между контейнером и локальной файловой системой
create - Создать новый контейнер
diff - Проверять изменения в файлах или каталогах в файловой системе контейнера
events - Получить события в реальном времени с сервера
exec - Запустить команду в работающем контейнере      
export - Экспортировать файловую систему контейнера как архив tar
history - Показать историю изменений
images - Показать доступные образы
import - Импорт содержимое из архива, чтобы создать образ файловой системы
info - Отображение информации о системе ( сколько контейнеров, работает, и т.д.)
inspect - Показать подробную информации об объектах Docker
kill - Завершить один или несколько работающих контейнеров
load - Загрузить образ из архива tar или STDIN
login - вход в реестор Docker
logout - выход из реестра Docker
logs - Получить журналы контейнера       
pause - Приостановить все процессы в одном или нескольких контейнерах
port - Список сопоставлений портов или конкретное сопоставление для контейнера
ps - Список контейнеров
pull - Вытащить изображение или хранилище из реестра
push - Добавить изображение или репозиторий в реестр
rename - Переименовать контейнер
restart - Перезапустите один или несколько контейнеров
rm - Удалить один или несколько контейнеров
rmi - Удалить одно или несколько изображений
run - Запустите команду в новом контейнере
save - Сохраните одно или несколько изображений в архив tar (по умолчанию передается в STDOUT)
search - Поиск образов Docker Hub
start - Запустить один или несколько остановленных контейнеров
stats - Отобразить живой поток статистики использования ресурсов контейнера (ов)
stop - Остановите один или несколько работающих контейнеров
tag - Создать тег TARGET_IMAGE, который ссылается на SOURCE_IMAGE
top - Отобразить запущенные процессы контейнера
unpause - Отмена приостановки всех процессов в одном или нескольких контейнерах
update - Обновить конфигурацию одного или нескольких контейнеров
version - Показать информацию о версии Docker
wait - ???что???Блокируйте, пока один или несколько контейнеров не остановятся, затем напечатайте их коды выхода

Получить список опций конкретной под команды:

docker docker-subcommand --help

docker подключение к контейнеру

docker create -it ubuntu:16.04 bash - создали контейнер
docker ps -a - посмотрели все контейнеры
docker start ИД_контейнера - запустили контейнер
docker attach ИД_контейнера - подключились к контейнеру

docker compose установка:

compose - требуется для сборки контейнеров
https://docs.docker.com/compose/install/ - офф. инструкция

sudo curl -L "https://github.com/docker/compose/releases/download/1.24.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose
sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose
docker-compose --version

Создание образа докер:

sudo docker run -it --name Имя_будущего_образа --hostname Имя_будущего_образа ubuntu bash - создаем контейнер с ubuntu и открываем консоль
-----------------------------------------------------------------------------------------
apt update && apt upgrade -y - обновим репозиторий
apt install cowsay - установим нужное приложение
ln -s /usr/games/cowsay /usr/bin/cowsay - !!! создаем символьную ссылку для запуска приложения
exit - входим из контейнера
-----------------------------------------------------------------------------------------

sudo docker commit Имя_будущего_образа Наш_логин_в_докер/Имя_будущего_образа - создаем образ 

sudo docker run Наш_логин_в_докер/Имя_будущего_образа cowsay "LOL" - проверяем работоспособность нашего образа
sudo docker run Наш_логин_в_докер/Имя_образа /usr/games/cowsay "LOL" - !!! если забыли создать символьную ссылку придется написать полный путь до приложения /usr/games/cowsay

sudo docker login - выполняем авторизацию на докер
sudo docker push Наш_логин_в_докер/Имя_будущего_образа - собственно загружаем наш образ в репозиторий докер

Запуск нашего контейнера:

sudo docker run Наш_логин_в_докер/Имя_образа cowsay "TEST"

docker создание образов / докер файл / dockerfile / настройка образа

mkdir Папка_для_образа - создаем папку
cd Папка_для_образа - переходим в папку для образа
touch dockerfile  - создаем файл dockerfile
vim dockerfile - открываем для редактирования
--------------
FROM ubuntu  - определяем ос для образа ( обязательно ) 
RUN apt update && apt upgrade -y && apt install cowsay -y  && ln -s /usr/games/cowsay /usr/bin/cowsay - выполняем установку программы cowsay и настраиваем ее
--------------
sudo docker login - выполняем авторизацию на докер
sudo docker build -t Наш_логин_в_докер/Имя_будущего_образа . - !!!в конце точка!!!  выполняем находясь в каталоге Папка_для_образа и образ будет собран и отправлен в репозиторий

sudo docker run Наш_логин_в_докер/Имя_будущего_образа cowsay "LOL" - проверяем работоспособность нашего образа

модификация образа:

vim dockerfile - открываем для редактирования
--------------
FROM ubuntu  - определяем ос для образа ( обязательно ) 

MAINTAINER имя_автора_образа почта@автора.образа - эта строчка ничего не делает \ инфо для связи с автором образа

RUN apt update && apt upgrade -y && apt install cowsay -y  && ln -s /usr/games/cowsay /usr/bin/cowsay - выполняем установку программы cowsay и настраиваем ее

ENTRYPOINT ["cowsay"]  - указываем точку входа - позволит при запуске ( sudo docker run Наш_логин_в_докер/Имя_будущего_образа cowsay "LOL" ) не писать cowsay
--------------
sudo docker build -t Наш_логин_в_докер/Имя_будущего_образа . - !!!в конце точка!!!  выполняем находясь в каталоге Папка_для_образа и образ будет собран и отправлен в репозиторий
sudo docker run Наш_логин_в_докер/Имя_будущего_образа "LOL" - проверяем работоспособность нашего образа

sudo docker push Наш_логин_в_докер/Имя_будущего_образа -  загружаем наш образ в репозиторий докер / реестор 

Еще пример своего образа sampleapp

0. ставим python и flask
apt install python3
pip3 install flask

1. Создаем каталог
mkdir sample_app.py

2. Переходим в sample_app.py и создаем файл sample_app.py
cd sample_app.py

vim sample_app.py
-----------------
from flask import Flask
from flask import request
from flask import render_template

sample = Flask(__name__)

@sample.route("/")
def main():
    return render_template("index.html") 

if __name__ == "__main__":
    sample.run(host="0.0.0.0", port=8080)
-----------------

3. Cоздание, сборка, запуск контейнера
vim sample_app.sh
#!/bin/bash
-----------
mkdir tempdir
mkdir tempdir/template
mkdir tempdir/static
cp sample_app.py tempdir/.
cp -r templates/* tempdir/templates/.
cp -r static/* tempdir/static/.

echo "From python" >> tempdir/Dockerfile
echo "RUN pip install flask" >> tempdir/Dockerfile

echo "COPY ./static /home/myapp/static" >> tempdir/Dockerfile
echo "COPY ./tamplate /home/myapp/templates/" tempdir/Dockerfile
echo "COPY sample_app.py /home/myapp/" >> tempdir/Dockerfile

echo "EXPOSE 8080" >> tempdir/Dockerfile

echo "CMD python3 /home/myapp/sample_app.py" >> tempdir/Dockerfile

cd tempdir
docker build -t sampleapp .
docker - rub -d -p 8080:8080 --name samplerunning sampleapp
docker ps -a
-----------

4. Запуск скрипта sample_app.sh
bash sample_app.sh

Docker работа с сетью / networking / драйверы:

bridge: 
Мост, — это сетевой драйвер по умолчанию. 
Бридж сеть используется, когда ваши приложения запускаются в автономных контейнерах, 
которые должны взаимодействовать между собой (Наглядный пример Nginx + MySQL).
Лучше всего использовать для связи  нескольких контейнеров на одном и том же Docker хосте. 
Можно юзать docker-compose и выберать даную сеть для такой связки

host:  
Хост, — это сетевой драйвер для автономных контейнеров (удаленная сетевая изоляция между контейнером и Docker хостом). 
Данный драйвер доступен только для docker-swarm с поддержкой Docker 17.06 и выше.
Лучше всего использовать, когда сетевой стек не должен быть изолирован от хоста Docker,
но вы хотите, чтобы другие аспекты контейнера были изолированы.

overlay/overlay2: 
Оверлей (Наложенная сеть), или наложение сетей — это сетевой драйвер для соединения несколько демонов Docker между собой 
и которые позволяют  docker-swarm службам взаимодействовать друг с другом. 
Вы также можете использовать оверлейные сети для облегчения связи между docker-swarm 
и автономным контейнером или между двумя отдельными контейнерами на разных Docker демонах. 
Эта стратегия устраняет необходимость выполнения маршрутизации на уровне ОС между этими контейнерами.
Лучше всего использовать, когда вам нужны контейнеры, работающие на разных Docker хостах для связи, или, 
когда несколько приложений работают вместе, используя docker-swarm.

macvlan: 
Маквлан,- это сетевой драйвер, который позволяют назначать MAC-адрес контейнеру, 
делая его отображаемым как физическое устройство в вашей сети. 
Docker демон направляет трафик на контейнеры по их MAC-адресам. 
Использование macvlan драйвера иногда является лучшим выбором при работе с устаревшими приложениями, 
которые ожидают, что они будут напрямую подключены к физической сети.
Лучше всего использовать, когда вы переходите с VM/дедикейта  на контейнеры или хотите, 
чтобы ваши контейнеры выглядели как физические хосты в вашей сети, каждый с уникальным MAC-адресом.


none:
Нон,- это сетевой драйвер, который умеет отключать всю сеть для контейнеров. 
Обычно используется в сочетании с пользовательским сетевым драйвером.

Network plugins: 
Вы можете установить и использовать сторонние сетевые плагины с Docker контейнерами. 
Эти плагины доступны в Docker Store или у сторонних поставщиков услуг.
Сторонние сетевые плагины позволяют интегрировать Docker со специализированными сетевыми стеками.

docker network ls

docker network ls - просмотреть сети в Docker

NETWORK ID —  При создании сети, ей присваивается ID. Так это собственно идентификатор сети.
NAME — Имя сети. Можно задать произвольное имя.
DRIVER — Используемый драйвер для созданной сети.
SCOPE — Где используется.

docker network create --driver=NAME NAME-NET

docker network create bridge-network - создать сеть bridge-network в Docker (по умолчанию создается bridge)
docker network create --driver=bridge bridge-network  - создать сеть bridge-network в Docker (--driver можно указать  bridge, overlay, host, none )
docker network create -d overlay my-multihost-network - создать сеть оверлей
docker network create --driver=overlay overlay_network - создать сеть оверлей
docker network create -d macvlan --subnet=172.16.86.0/24 --gateway=172.16.86.1 -o parent=eth0 my-macvlan-net - создать сеть macvlan

docker network create --subnet 10.1.0.0/16 --gateway=10.1.0.1 --ip-range 10.1.4.0/24 --driver=bridge --label=host4networks brifge04 - создать сеть bridge
docker run -it --name=test_brifge04 --net brifge04 centos:centos7 /bin/bash - проверка
docker run -it --name=test_brifge04_2 --net brifge04 --ip=10.1.4.100 centos:centos7 /bin/bash - проверка контейнеру даем статический ip

docker network connect | disconnect

docker network connect YOUR_NETWORK YOUR_CONTAINER - подключить контейнер(ы) к сети в Docker
docker network disconnect YOUR_NETWORK YOUR_CONTAINER - отключить контейнер(ы) от сети в Docker

YOUR_NETWORK — Сеть
YOUR_CONTAINER — Контейнер

docker network inspect

docker network inspect bridge-network - позволяет получить подробную информацию о сети с имене bridge-network в  Docker 

docker network rm

docker network rm YOUR_NETWORK - удаление сети YOUR_NETWORK в Docker

docker контейнеры использование внешних каталогов / томов:

Контейнеры или протокол без сохранения состояния?
Каждый контейнер изолирован и не сохраняет состояние. 
Это означает, что после удаления контейнера его содержимое будет удалено навсегда.

docker create -it -v $(pwd):/var/www ubuntu:latest bash

При создании нового контейнера добавьте флаг -v, чтобы указать, какой том создать. 
Эта команда привяжет текущий рабочий каталог на компьютере к директории /var/www внутри контейнера.