Как создать контейнер докер python

Как создать Docker контейнер для работы скрипта на Python?

Мне нужно создать Docker файл для моего скрипта на Python, который состоит из файлов .py , виртуального окружения и .exe файла необходимого для работы скрипта. Суть скрипта — скрипт используется для парсинга на Selenium, поэтому для работы необходим файл драйвера chormedriver.exe . В контейнер это нужно обернуть, чтобы скрипт мог работать на нужном мне хостинге. Вот код который у меня есть:

# Код из .py файла, где используется chromedriver.exe global driver driver = webdriver.Chrome(options=options, executable_path=r"chromedriver.exe") driver.get(f"https://www.wildberries.ru/catalog//feedbacks?imtId=") time.sleep(5) big_stat = driver.find_element(by=By.CLASS_NAME, value="rating-product__numb") 

Код Dockerfile, который мне посоветовали написать:

FROM ubuntu:18.04 RUN apt-get -o Acquire::Check-Valid-Until=false -o Acquire::Check-Date=false update RUN apt-get install -y python3 python3-pip python3-setuptools python3-dev python-distribute RUN alias python=python3 RUN echo "alias python=python3" >> ~/.bashrc RUN apt-get -qy --no-install-recommends install \ sudo \ unzip \ wget \ curl \ libxi6 \ libgconf-2-4 \ vim \ xvfb \ && rm -rf /var/lib/apt/lists/* RUN curl -sS -o - https://dl-ssl.google.com/linux/linux_signing_key.pub | apt-key add - && \ echo "deb http://dl.google.com/linux/chrome/deb/ stable main" >> /etc/apt/sources.list.d/google-chrome.list && \ apt-get -yqq update && \ apt-get -yqq install google-chrome-stable && \ rm -rf /var/lib/apt/lists/* RUN apt-get -qy --no-install-recommends install \ $(apt-cache depends firefox | grep Depends | sed "s/.*ends:\ //" | tr '\n' ' ') \ && rm -rf /var/lib/apt/lists/* \ && cd /tmp \ && wget --no-check-certificate -O firefox-esr.tar.bz2 \ 'https://download.mozilla.org/?product=firefox-esr-latest&os=linux64&lang=en-US' \ && tar -xjf firefox-esr.tar.bz2 -C /opt/ \ && ln -s /opt/firefox/firefox /usr/bin/firefox \ && rm -f /tmp/firefox-esr.tar.bz2 RUN set -e RUN echo "Starting X virtual framebuffer (Xvfb) in background. " RUN Xvfb -ac :99 -screen 0 1280x1024x16 > /dev/null 2>&1 & RUN export DISPLAY=:99 RUN exec "$@" RUN apt-get update -y RUN apt-get -qy --no-install-recommends install python3.8 RUN rm /usr/bin/python3 RUN ln -s python3.8 /usr/bin/python3 RUN export PYTHONIOENCODING=utf8 RUN echo "export PYTHONIOENCODING=utf8" >> ~/.bashrc COPY sbase /SeleniumBase/sbase/ COPY seleniumbase /SeleniumBase/seleniumbase/ COPY examples /SeleniumBase/examples/ COPY integrations /SeleniumBase/integrations/ COPY requirements.txt /SeleniumBase/requirements.txt COPY setup.py /SeleniumBase/setup.py RUN find . -name '*.pyc' -delete RUN find . -name __pycache__ -delete RUN pip3 install --upgrade pip RUN pip3 install --upgrade setuptools RUN pip3 install --upgrade setuptools-scm RUN cd /SeleniumBase && ls && pip3 install -r requirements.txt --upgrade RUN cd /SeleniumBase && pip3 install . RUN wget https://github.com/mozilla/geckodriver/releases/download/v0.31.0/geckodriver-v0.31.0-linux64.tar.gz RUN tar -xvzf geckodriver-v0.31.0-linux64.tar.gz RUN chmod +x geckodriver RUN mv geckodriver /usr/local/bin/ RUN wget https://chromedriver.storage.googleapis.com/2.44/chromedriver_linux64.zip RUN unzip chromedriver_linux64.zip RUN chmod +x chromedriver RUN mv chromedriver /usr/local/bin/ COPY integrations/docker/docker-entrypoint.sh / COPY integrations/docker/run_docker_test_in_firefox.sh / COPY integrations/docker/run_docker_test_in_chrome.sh / RUN chmod +x *.sh COPY integrations/docker/docker_config.cfg /SeleniumBase/examples/ ENTRYPOINT ["/docker-entrypoint.sh"] CMD ["/bin/bash"] 

Контейнеризации Python-приложений

Контейнеризация Python-приложений с помощью Docker – это отличный способ сделать их более переносимыми, масштабируемыми и безопасными. В этой статье мы рассмотрим 7 простых шагов по контейнеризации Python-приложения с помощью Docker

Шаг 1: Установка базового образа

Первым шагом является выбор базового образа для контейнера. Мы рекомендуем использовать минимальный базовый образ, например python:3.11-slim. Это позволит уменьшить размер контейнера и повысить его безопасность.

Шаг 2: Создание непривилегированного пользователя

Официальный образ контейнера Python не содержит предустановленного непривилегированного пользователя. Поэтому нам необходимо его создать. Мы создадим пользователя с UID 1000 и GID 1000.

RUN groupadd -g 1000 python && \ useradd -r -u 1000 -g python python

Шаг 3: Копирование и установка зависимостей

Если ваше приложение имеет какие-либо зависимости, то их необходимо скопировать в контейнер и установить. Это можно сделать с помощью инструкций COPY и RUN.

COPY requirements.txt . RUN pip install -r requirements.txt

Шаг 4: Настройка рабочего каталога

Далее необходимо создать внутри контейнера каталог, в котором будет храниться исходный код нашего приложения. Мы создадим каталог /app и убедимся, что он принадлежит непривилегированному пользователю, которого мы создали на шаге 2.

RUN mkdir /app && chown python:python /app WORKDIR /app

Шаг 5: Скопируйте код приложения

Теперь необходимо скопировать исходный код нашего приложения в рабочий каталог.

Шаг 6: Запуск от имени непривилегированного пользователя

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

Шаг 7: Задание команды входа

Наконец, необходимо указать, какая команда должна быть выполнена при запуске контейнера. Мы хотим выполнить исходный код нашего приложения, поэтому используем инструкцию CMD.

CMD [«python», «app.py»]

После выполнения этих шагов можно собрать образ Docker с помощью следующей команды:

docker build -t my-python-app .

Для запуска контейнера можно воспользоваться следующей командой:

docker run -p 8080:80 my-python-app

Это приведет к запуску контейнера и открытию порта 8080 на хост-машине. Теперь вы можете получить доступ к своему приложению по адресу http://localhost:8080.

Ниже приведен пример Dockerfile для простого Python-приложения:

FROM python:3.11-slimRUN groupadd -g 1000 python && \ useradd -r -u 1000 -g python python COPY requirements.txt . RUN pip install -r requirements.txt RUN mkdir /app && chown python:python /app WORKDIR /app COPY app.py . USER 1000 CMD [«python», «app.py»]

Для создания образа Docker необходимо выполнить следующую команду:

docker build -t my-python-app .

Для запуска контейнера необходимо выполнить следующую команду:

docker run -p 8080:80 my-python-app

Это приведет к запуску контейнера и открытию порта 8080 на хост-машине. После этого вы сможете получить доступ к своему приложению по адресу http://localhost:8080.

Надеюсь, эта статья была полезной!

Вот несколько дополнительных советов по контейнеризации Python-приложений:

• Используйте многоступенчатую сборку, чтобы отделить процесс сборки от среды выполнения. Это позволит сделать образ Docker меньше и эффективнее.
• Используйте тома для монтирования каталогов с хост-машины в контейнер. Это позволит разрабатывать и отлаживать приложение внутри контейнера без необходимости пересобирать образ при каждом изменении.
• Использовать реестр Docker для хранения и совместного использования образов Docker.Надеюсь, вы сделаете это быстрее ��

Контейнеризация в Python. Часть 1

Разработка в Python в локальных средах может стать нелёгкой задачей, если одновременно работать более чем над одним проектом. Бутстрэппинг (начальная загрузка) проекта может потребовать некоторого времени: нужно согласовать версии, а также настроить зависимости и конфигурацию. Раньше мы устанавливали все требования к проектам напрямую в нашу локальную среду разработки и фокусировались на написании кода. Однако при ведении нескольких проектов в одной среде уже возникают сложности, так как мы можем столкнуться с конфликтами конфигурации или зависимостей. Более того, если мы начинаем работать совместно с коллегами, то наши среды разработки уже приходится координировать. Поэтому нам нужно определить среду проекта так, чтобы её могли с лёгкостью использовать другие.

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

В текущей части мы рассмотрим, как помещать в контейнер Python-службу или инструмент и познакомимся с наилучшими подходами для осуществления данного процесса.

Требования

Для простоты работы с материалами этой и двух последующих статей нужно установить минимальный набор инструментов, которые позволят управлять помещёнными в контейнеры средами локально:

• Windows или macOS: установите Docker Desktop.
• Linux: установите Docker, а затем Docker Compose.

Контейнеризация сервера Python

В качестве примера мы возьмём простой сервер Flask, который можно запустить автономно, не устанавливая другие компоненты.

server.pyfrom flask import Flask
server = Flask(__name__)@server.route("/") 
def hello(): 
return "Hello World!"if __name__ == "__main__": 
server.run()

Перед запуском этой программы сначала нужно убедиться в наличии всех необходимых зависимостей. Один из способов управления ими — применение установщика пакетов, например pip. Для этого нужно создать файл requirements.txt и записать в него зависимости. Ниже приведён пример такого файла для нашего простого server.py :

requirements.txtFlask==1.1.1

app
├─── requirements.txt
└─── src 
└─── server.py

Мы создаём выделенную директорию для исходного кода, чтобы изолировать его от других файлов конфигурации. Позже вы увидите, зачем мы это делаем. Для выполнения программы осталось только установить интерпретатор Python и запустить его.

Можно запустить программу локально, но так мы отклонимся от нашей задачи по контейнеризации разработки, которая подразумевает чистую стандартную среду разработки, позволяющую легко переключаться между проектами с разными конфликтующими требованиями. Я расскажу, как легко поместить этот сервис Python в контейнер.

Dockerfile

Чтобы осуществить работу нашего Python-кода в контейнере мы упакуем его как образ Docker, а затем запустим на основе этого образа контейнер:

Для генерации образа Docker нужно создать Dockerfile, содержащий необходимые для сборки образа инструкции. Затем Dockerfile обрабатывается сборщиком Docker, который и сгенерирует нужный образ. После этого с помощью простой команды docker run мы создаём и запускаем контейнер с сервером Python.

Анализ Dockerfile

Ниже приведён пример Dockerfile, содержащего инструкции по сборке образа для нашего сервиса hello world :

Dockerfile# установка базового образа (host OS)
FROM python:3.8# установка рабочей директории в контейнере
WORKDIR /code# копирование файла зависимостей в рабочую директорию
COPY requirements.txt .# установка зависимостей
RUN pip install -r requirements.txt# копирование содержимого локальной директории src в рабочую директорию
COPY src/ .# команда, выполняемая при запуске контейнера
CMD [ "python", "./server.py" ]

Для каждой инструкции или команды из Dockerfile сборщик Docker генерирует слой образа и накладывает его на предыдущие. Таким образом, получающийся в результате образ Docker представляет собой простой только читаемый стэк, состоящий из разных слоёв. В выводе команды сборки мы видим, как по очереди выполняются инструкции Dockerfile:

$ docker build -t myimage .
Sending build context to Docker daemon 6.144kB
Step 1/6 : FROM python:3.8
3.8.3-alpine: Pulling from library/python
…
Status: Downloaded newer image for python:3.8.3-alpine
---> 8ecf5a48c789
Step 2/6 : WORKDIR /code
---> Running in 9313cd5d834d
Removing intermediate container 9313cd5d834d
---> c852f099c2f9
Step 3/6 : COPY requirements.txt .
---> 2c375052ccd6
Step 4/6 : RUN pip install -r requirements.txt
---> Running in 3ee13f767d05
…
Removing intermediate container 3ee13f767d05
---> 8dd7f46dddf0
Step 5/6 : COPY ./src .
---> 6ab2d97e4aa1
Step 6/6 : CMD python server.py
---> Running in fbbbb21349be
Removing intermediate container fbbbb21349be
---> 27084556702b
Successfully built 70a92e92f3b5
Successfully tagged myimage:latest

Затем можно проверить образ в локальном хранилище образов:

$ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
myimage latest 70a92e92f3b5 8 seconds ago 991MB

В процессе разработки нам может потребоваться повторно собрать образ для Python-сервиса, на что желательно потратить как можно меньше времени. Далее мы проанализируем некоторые лучшие практики, которые могут нам в этом помочь.

Лучшие практики разработки Dockerfile

Базовый образ

Первая инструкция из Dockerfile определяет базовый образ, поверх которого мы добавляем новые слои для приложения. Выбор базового слоя весьма важен, поскольку поставляемые им возможности могут влиять на качество надстроенных слоёв.

По возможности старайтесь работать с официальными образами, которые, как правило, часто обновляются и имеют меньше проблем с безопасностью.

Выбор базового образа также влияет на размер итогового. Если для вас размер имеет первостепенное значение, то можно выбрать какой-нибудь очень маленький нетребовательный к ресурсам образ. Такие образы обычно основываются на дистрибутиве Alpine и имеют соответствующий тег. Тем не менее для приложений Python в большинстве случаев отлично подходит slim-вариант официального Python-образа Docker (например, python:3.8-slim )

Порядок инструкций влияет на использование кэша сборки

При частой сборке образа мы определённо будем использовать механизм кэширования для ускорения. Как я упоминала ранее, инструкции Dockerfile выполняются в заданном порядке. Для каждой инструкции сборщик сначала проверяет свой кэш на наличие образа для повторного использования. При обнаружении изменения в слое этот и все последующие слои пересобираются. Чтобы кэширование было эффективным, нужно поместить инструкции часто изменяемых слоёв после тех, которые меняются редко.

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

. 
# копирование файла зависимостей в рабочую директорию
COPY requirements.txt .# установка зависимостей
RUN pip install -r requirements.txt# копирование содержимого локальной директории src в рабочую директорию
COPY src/ .
. 

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

Многоэтапные сборки

Хотя это может и не быть существенным в разработке, мы кратко расскажем о подобных сборках, поскольку они интересны в плане итоговой отправки контейнеризованного приложения уже по её завершении.

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

# первый этап
FROM python:3.8 AS builder
COPY requirements.txt .# установка зависимостей в локальную директорию user (например, /root/.local)
RUN pip install --user -r requirements.txt# второй этап (без названия)
FROM python:3.8-slim
WORKDIR /code# копирование только установки зависимостей из образа первого этапа 
COPY --from=builder /root/.local/bin /root/.local
COPY ./src .# обновление переменной среды PATH
ENV PATH=/root/.local:$PATHCMD [ "python", "./server.py" ]

Обратите внимание, что здесь мы используем двухэтапную сборку, где только первый этап называем builder — сборщик. Название этапу мы задаём, добавляя AS к инструкции FROM и используем это название в инструкции COPY , где хотим скопировать в итоговый образ только необходимые файлы. Результат — облегчённый образ:

$ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
myimage latest 70a92e92f3b5 2 hours ago 991MB
multistage latest e598271edefa 6 minutes ago 197MB
…

В этом примере мы установили зависимости в локальную директорию user и скопировали эту директорию в итоговый образ с помощью опции pip -user . Однако для выполнения этих действий есть и другие решения вроде virtualenv или сборки в виде пакетов wheel с последующим их копированием и установкой в итоговый образ.

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

После написания Dockerfile и сборки образа, мы запускаем контейнер с нашим сервисом:

$ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
myimage latest 70a92e92f3b5 2 hours ago 991MB
. $ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES$ docker run -d -p 5000:5000 myimage
befb1477c1c7fc31e8e8bb8459fe05bcbdee2df417ae1d7c1d37f371b6fbf77f

Мы и поместили в контейнер сервер hello world и теперь можем запросить порт, сопоставленный с localhost:

$ docker ps
CONTAINER ID IMAGE COMMAND PORTS . 
befb1477c1c7 myimage "/bin/sh -c 'python . " 0.0.0.0:5000->5000/tcp . $ curl http://localhost:5000
"Hello World!"

Что дальше?

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

В следующей статье вы узнаете, как настроить основанный на контейнерах многосервисный проект, где Python-компонент соединён с внешними компонентами, а также научитесь управлять жизненным циклом всех компонентов проекта при помощи Docker Compose.

• Пять действительно крутых пакетов Python
• Встроенная база данных Python
• Пространства имен и области видимости в Python

Установка Python в Docker — от запуска контейнера до создания рабочей среды

Новые версии Python разрабатывают всё время. Но каждый раз компилировать его самому, чтобы попробовать новую версию, довольно обременительно.

Выход из этой ситуации прост — запускать различные версии Python через Docker.

Из этого руководства вы узнаете:

• Какие версии Python доступны.
• Как начать работу с Docker.
• Как запускать определённую версию Python в контейнерах Docker.
• Как использовать контейнеры Docker в качестве рабочих сред Python.

Docker и версии Python

С прекращением поддержки Python 2.7 в 2020 году, долгий переход от Python 2 к Python 3 вошел в финальную фазу. Однако, двигаясь вперёд, важно знать о различных версиях Python и о том, как их опробовать.

Типы версий Python

1. Официальные релизы (Released versions). Обычно, в этом случае речь идёт о чём-то вроде Python 3.6, 3.7 или 3.8. В каждой из этих версий добавлены новые возможности. Поэтому, чтобы правильно оценивать функционал, нужно знать, какая именно версия релиза запущена. К примеру, f-строки (метод форматирования f-strings) ввели в Python 3.6. На более ранних версиях он не работает. Подобным образом, выражения присваивания доступны только начиная с Python 3.8.
2. Разрабатываемые версии (Development versions). Сообщество Python постоянно работает над новыми версиями. Пользователям доступны разрабатываемые версии, отмеченные как альфа, бета и релиз-кандидат (release candidate).
3. Реализации (Implementations). Python — язык, имеющий несколько вариантов дополнительных реализаций на основе вышедших официальных версий. Каждая из них содержит интерпретатор и соответствующие библиотеки. CPython — эталонная реализация Python, ее используют чаще всего. Тем не менее есть и другие реализации, ориентированные под специфические нужды. Среди них PyPy, IronPython, Jython, MicroPython и CircuitPython.

Версию используемого Python можно увидеть при запуске интерпретатора REPL. Можно также получить дополнительную информацию c помощью команды «sys.implementation».

>>> import sys >>> sys.implementation.name 'cpython' >>> sys.implementation.version sys.version_info(major=3, minor=9, micro=0, releaselevel='alpha', serial=1)

Как видно, код выполнен на первой альфа-версии CPython 3.9.

Традиционно для управления различными версиями Python используются инструменты вроде «pyenv» и «conda». В большинстве случаев их может заменить Docker. И он часто оказывается проще в использовании. Ниже мы практически покажем, как это сделать.

Использование Docker

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

Установка Docker

Docker доступен для всех основных ОС: Windows, macOS и Linux. Инструкции по установке Docker на конкретную систему можно найти в их официальных руководствах.

Если специфических требований нет, можно использовать ядро приложения — Docker Engine — в свободно распространяемой «общественной» редакции (Community Edition).

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

Работа Docker основана на двух базовых элементах — образах и контейнерах.

• Образ — автономный пакет, который может выполнить Docker.
• Контейнер — выполняемый образ с определённым состоянием (как пользовательский процесс).

Есть несколько репозиториев, содержащих предварительно собранные образы для Docker. Самым распространённым является Docker Hub — публичный репозиторий, который будет использоваться в данном руководстве по умолчанию.

Для примера установим образ «hello-world».

$ docker run hello-world Unable to find image 'hello-world:latest' locally latest: Pulling from library/hello-world 1b930d010525: Pull complete Digest: sha256:451ce787d12369c5df2a32c85e5a03d52cbcef6eb3586dd03075f3. Status: Downloaded newer image for hello-world:latest Hello from Docker! This message shows that your installation appears to be working correctly. [ . Результат выполнения команды сокращён . ]

Первые строки показывают, что Docker скачал образ «hello-world» из репозитория Docker Hub. При запуске этого образа итоговый контейнер выводит на терминал сообщение «Hello from Docker!».

Создание собственных образов с помощью Dockerfile

С помощью Dockerfile можно создавать собственные образы. Это обычный текстовый файл, который описывает, как именно будет устанавливаться образ Docker.

Вот пример Dockerfile:

FROM ubuntu RUN apt update && apt install -y cowsay CMD ["/usr/games/cowsay", "Dockerfile это круто!"]

Файл Dockerfile состоит из перечня команд Docker. В приведённом выше фрагменте три шага:

• Строка 1 создаёт на базе существующего образа под названием «ubuntu» новый. Она выполнима вне зависимости от ОС, на которой запущен Docker.
• Строка 2 устанавливает программу под названием «cowsay».
• Строка 3 задаёт команду, которая сразу запускает «cowsay» при выполнении образа.

Создание Dockerfile начинается с правильного сохранения — под именем «Dockerfile» без какого-либо расширения.

Примечание. Создавать и запускать образы Linux можно на любой платформе. Поэтому такие образы, как «ubuntu», прекрасно подходят для разработки кросс-платформенных приложений. В то же время образ Windows запустится только на Windows, а образ macOS — только на macOS.

Далее создаём при помощи Dockerfile образ:

$ docker build -t cowsay

В результате последует множество сообщений, и будет создан образ. Опция «-t cowsay» задаёт «cowsay» в качестве его имени. Такие теги удобно использовать для отслеживания образов. Финальная точка в команде указывает текущий каталог в качестве контекста сборки для вашего образа. Это должен быть каталог, где находится ваш Dockerfile.

Теперь образ Docker можно выполнить:

$ docker run --rm cowsay _______________________ < Dockerfile это круто! >----------------------- \ ^__^ \ (oo)\_______ (__)\ )\/\ ||----w | || ||

Опция « —rm » очистит контейнер после использования. Её применение позволяет не засорять систему уже ненужными контейнерами Docker.

Примечание. Вывести список ваших образов и контейнеров можно, используя команду «docker ps -a».

И образ, и контейнер имеют 12-символьный идентификатор «ID», который можно найти в результатах выполнения этих команд. Чтобы удалить образ или контейнер, можно использовать «docker rmi » либо «docker rm », указав их правильный идентификатор.

$ docker run -it --rm python:rc Python 3.8.0rc1 (default, Oct 2 2019, 23:30:03) [GCC 8.3.0] on linux Type "help", "copyright", "credits" or "license" for more information. >>>

>>> import sys >>> f"" "sys.version_info[:] = (3, 8, 0, 'candidate', 1)"

$ docker run -it --rm quay.io/python-devs/ci-image:master

FROM python:3.7.5-slim RUN python -m pip install \ parse \ realpython-reader

FROM python:3.7.5-slim # Настроить и активировать виртуальную среду ENV VIRTUAL_ENV "/venv" RUN python -m venv $VIRTUAL_ENV ENV PATH "$VIRTUAL_ENV/bin:$PATH" # Команды Python будут выполнены в виртуальной среде RUN python -m pip install \ parse \ realpython-reader

$ docker build -t rp . [ . Результат выполнения команды сокращён . ] $ docker run -it --rm rp

>>> import parse >>> parse.__version__ '1.12.1'

$ docker run --rm rp realpython The latest tutorials from Real Python (https://realpython.com/) 0 Run Python Versions in Docker: How to Try the Latest Python Release [ . Результат выполнения команды сокращён . ]

# headlines.py import parse from reader import feed tutorial = feed.get_article(0) headlines = [ r.named["header"] for r in parse.findall("\n## \n", tutorial) ] print("\n".join(headlines))

$ docker run --rm -v /home/realpython/code:/app rp python /app/headlines.py Understanding Python Versions and Docker Using Docker Running Python in a Docker Container Conclusion Further Reading

FROM python:3.7.5-slim WORKDIR /usr/src/app RUN python -m pip install \ parse \ realpython-reader COPY headlines.py . CMD ["python", "headlines.py"]

$ docker build -t rp . [ . Результат выполнения команды сокращён . ] $ docker run --rm rp Understanding Python Versions and Docker Using Docker Running Python in a Docker Container Conclusion Further Reading