Hay varias cosas que se deben tener en cuenta al usar la poetry junto con la docker .

Instalación

La forma oficial de instalar poetry es a través de:

 curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py | python -

De esta forma, la poetry y sus dependencias pueden aislarse de sus dependencias. Pero, bajo mi punto de vista, no es muy bueno por dos razones:

1. La versión de poetry podría obtener una actualización y romperá su compilación. En este caso, puede especificar la variable de entorno POETRY_VERSION . El instalador lo respetará
2. No me gusta la idea de canalizar cosas de Internet a mis contenedores sin ninguna protección contra posibles modificaciones de archivos.

Entonces, uso pip install 'poetry==$POETRY_VERSION' . Como puede ver, todavía recomiendo fijar su versión.

Además, ancle esta versión en su pyproject.toml también:

 [build-system] # Should be the same as `$POETRY_VERSION`: requires = ["poetry>=1.0"] build-backend = "poetry.masonry.api"

Lo protegerá de la discrepancia de versiones entre su entorno local y docker .

Dependencias de almacenamiento en caché

Queremos almacenar en caché nuestros requisitos y solo reinstalarlos cuando cambien los archivos pyproject.toml o poetry.lock . De lo contrario, las compilaciones serán lentas. Para lograr que la capa de caché funcione, debemos poner:

 COPY poetry.lock pyproject.toml /code/

Después de que se instale la poetry , pero antes de que se agreguen otros archivos.

Entorno virtual

Lo siguiente a tener en cuenta es la creación de virtualenv . No lo necesitamos en docker . Ya está aislado. Entonces, usamos la poetry config virtualenvs.create false setting para apagarlo.

Desarrollo vs Producción

Si usa el mismo Dockerfile para el desarrollo y la producción que yo, necesitará instalar diferentes conjuntos de dependencias en función de alguna variable de entorno:

 poetry install $(test "$YOUR_ENV" == production && echo "--no-dev")

De esta manera, $YOUR_ENV controlará qué conjunto de dependencias se instalará: todas (predeterminado) o producción solo con el indicador --no-dev .

También es posible que desee agregar algunas opciones más para una mejor experiencia:

1. --no-interaction no hacer preguntas interactivas
2. --no-ansi para hacer que su salida sea más fácil de registrar

Resultado

Terminarás con algo similar a:

 FROM python:3.6.6-alpine3.7 ARG YOUR_ENV ENV YOUR_ENV=${YOUR_ENV} \ PYTHONFAULTHANDLER=1 \ PYTHONUNBUFFERED=1 \ PYTHONHASHSEED=random \ PIP_NO_CACHE_DIR=off \ PIP_DISABLE_PIP_VERSION_CHECK=on \ PIP_DEFAULT_TIMEOUT=100 \ POETRY_VERSION=1.0.0 # System deps: RUN pip install "poetry==$POETRY_VERSION" # Copy only requirements to cache them in docker layer WORKDIR /code COPY poetry.lock pyproject.toml /code/ # Project initialization: RUN poetry config virtualenvs.create false \ && poetry install $(test "$YOUR_ENV" == production && echo "--no-dev") --no-interaction --no-ansi # Creating folders, and files for a project: COPY . /code

Puede encontrar un ejemplo de la vida real completamente funcional aquí: wemake-django-template

Actualización el 2019-12-17

• Actualizar poetry a 1.0

Compilación de Docker de varias etapas con Poetry y venv

No deshabilite la creación de virtualenv. Virtualenvs tiene un propósito en las compilaciones de Docker , ya que proporcionan una forma elegante de aprovechar las compilaciones de varias etapas. En pocas palabras, su etapa de compilación instala todo en el virtualenv, y la etapa final simplemente copia el virtualenv en una imagen pequeña.

Use poetry export e instale primero sus requisitos anclados, antes de copiar su código. Esto le permitirá usar el caché de compilación de Docker y nunca reinstalar las dependencias solo porque cambió una línea en su código.

No use la instalación de poetry install para instalar su código, ya que realizará una instalación editable. En su lugar, use la compilación de poetry build para construir una rueda y luego instálela en su virtualenv. (Gracias a PEP 517 , todo este proceso también podría realizarse con una pip install . simple, pero debido al aislamiento de compilación , terminaría instalando otra copia de Poetry).

Aquí hay un Dockerfile de ejemplo que instala una aplicación Flask en una imagen de Alpine, con una dependencia de Postgres. Este ejemplo utiliza un script de punto de entrada para activar virtualenv. Pero, en general, debería estar bien sin un script de punto de entrada porque simplemente puede hacer referencia al binario de Python en /venv/bin/python en su instrucción CMD .

Dockerfile

 FROM python:3.7.6-alpine3.11 as base ENV PYTHONFAULTHANDLER=1 \ PYTHONHASHSEED=random \ PYTHONUNBUFFERED=1 WORKDIR /app FROM base as builder ENV PIP_DEFAULT_TIMEOUT=100 \ PIP_DISABLE_PIP_VERSION_CHECK=1 \ PIP_NO_CACHE_DIR=1 \ POETRY_VERSION=1.0.5 RUN apk add --no-cache gcc libffi-dev musl-dev postgresql-dev RUN pip install "poetry==$POETRY_VERSION" RUN python -m venv /venv COPY pyproject.toml poetry.lock ./ RUN poetry export -f requirements.txt | /venv/bin/pip install -r /dev/stdin COPY . . RUN poetry build && /venv/bin/pip install dist/*.whl FROM base as final RUN apk add --no-cache libffi libpq COPY --from=builder /venv /venv COPY docker-entrypoint.sh wsgi.py ./ CMD ["./docker-entrypoint.sh"]

docker-entrypoint.sh

 #!/bin/sh set -e . /venv/bin/activate while ! flask db upgrade do echo "Retry..." sleep 1 done exec gunicorn --bind 0.0.0.0:5000 --forwarded-allow-ips='*' wsgi:app

wsgi.py

 import your_app app = your_app.create_app()

TL;RD

Pude configurar poetry para un proyecto de Django usando postgres . Después de investigar un poco, terminé con el siguiente Dockerfile :

 FROM python:slim # Keeps Python from generating .pyc files in the container ENV PYTHONDONTWRITEBYTECODE 1 # Turns off buffering for easier container logging ENV PYTHONUNBUFFERED 1 # Install and setup poetry RUN pip install -U pip \ && apt-get update \ && apt install -y curl netcat \ && curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py | python - ENV PATH="${PATH}:/root/.poetry/bin" WORKDIR /usr/src/app COPY . . RUN poetry config virtualenvs.create false \ && poetry install --no-interaction --no-ansi # run entrypoint.sh ENTRYPOINT ["/usr/src/app/entrypoint.sh"]

Este es el contenido de entrypoint.sh :

 #!/bin/sh if [ "$DATABASE" = "postgres" ] then echo "Waiting for postgres..." while ! nc -z $SQL_HOST $SQL_PORT; do sleep 0.1 done echo "PostgreSQL started" fi python manage.py migrate exec "$@"

Explicación detallada

Algunos puntos a notar:

• Decidí usar slim en lugar de alpine como etiqueta para la imagen de python porque aunque se supone que las imágenes alpine reducen el tamaño de las imágenes de Docker y aceleran la compilación, con Python, en realidad puedes terminar con una imagen un poco más grande y eso tarda un tiempo en construirse (lea este artículo para obtener más información).

• El uso de esta configuración genera contenedores más rápido que el uso de la imagen alpina porque no necesito agregar algunos paquetes adicionales para instalar los paquetes de Python correctamente.

• Estoy instalando poetry directamente desde la URL proporcionada en la documentación. Soy consciente de las advertencias proporcionadas por sobolevn . Sin embargo, considero que a largo plazo es mejor usar la última versión de poetry por defecto que depender de una variable de entorno que debo actualizar periódicamente.

• Actualizar la variable de entorno PATH es crucial. De lo contrario, obtendrá un error que indica que no se encontró la poesía .

• Las dependencias se instalan directamente en el intérprete de python del contenedor. No crea poetry para crear un entorno virtual antes de instalar las dependencias.

En caso de que necesite la versión alpine de este Dockerfile :

 FROM python:alpine # Keeps Python from generating .pyc files in the container ENV PYTHONDONTWRITEBYTECODE 1 # Turns off buffering for easier container logging ENV PYTHONUNBUFFERED 1 # Install dev dependencies RUN apk update \ && apk add curl postgresql-dev gcc python3-dev musl-dev openssl-dev libffi-dev # Install poetry RUN pip install -U pip \ && curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py | python - ENV PATH="${PATH}:/root/.poetry/bin" WORKDIR /usr/src/app COPY . . RUN poetry config virtualenvs.create false \ && poetry install --no-interaction --no-ansi # run entrypoint.sh ENTRYPOINT ["/usr/src/app/entrypoint.sh"]

Tenga en cuenta que la versión alpine necesita algunas dependencias postgresql-dev gcc python3-dev musl-dev openssl-dev libffi-dev para funcionar correctamente.