The run.sh script includes an example of invoking docker run for local development, mounting the source code for the project into the container so that edits are reflected immediately. The compose.yml file includes a Docker compose definition for the web application. It includes a watch directive for Docker compose, which is a best-practice method for updating the container on local changes. The Python application code for the project is at src/uv_docker_example/__init__.py — there's a command line entrypoint and a basic FastAPI application — both of which just display "hello world" output.

# Use a Python image with uv pre-installed · FROM ghcr.io/astral-sh/uv:python3.12-bookworm-slim · · # Setup a non-root user · RUN groupadd --system --gid 999 nonroot \ && useradd --system --gid 999 --uid 999 --create-home nonroot · · # Install the project into `/app` WORKDIR /app ·

2 weeks ago - Use one of the above images with ... install -y --no-install-recommends curl ca-certificates # Download the latest installer ADD https://astral.sh/uv/install.sh /uv-installer.sh # Run the installer then remove it RUN sh /uv-installer.sh && rm /uv-installer.sh # Ensure the installed ...

USER appuser ENTRYPOINT ["python", "-m", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]Copy code · The runtime stage uses a clean slim image and creates a non-root user for security. We copy the entire application including the virtual environment from the build stage and set proper ownership. Cache mounts in this Dockerfile speed up builds by persisting the package manager cache.

uv run effectively runs uv sync before each, meaning we always need to include --no-dev in any case where uv run is used or we'll end up installing the packages in each container or syncing the environment each time uv run is called. ... docker build . -f Dockerfile.multi.python.alpine -t uv-multi-python-alpine docker run --rm uv-multi-python-alpine

March 8, 2025 - /app RUN --mount=type=cache,target=/root/.cache/uv \ uv sync --frozen --no-dev --no-editable # Then, use a final image without uv FROM gcr.io/distroless/cc # Copy the Python version COPY --from=builder --chown=python:python /python /python WORKDIR /app # Copy the application from the builder COPY --from=builder --chown=app:app /app/.venv /app/.venv # Place executables in the environment at the front of the path ENV PATH="/app/.venv/bin:$PATH" # Run the FastAPI application by default CMD ["fastapi", "run", "--host", "0.0.0.0", "/app/.venv/lib/python3.12/site-packages/uv_docker_example"]

An example "getting started" python project based on `uv` - uv-getting-started/Dockerfile at main · gdamjan/uv-getting-started

Some single and multi stage Dockerfile examples using uv - uv-docker-examples/Dockerfile.multi.python.alpine at main · shaunhegarty/uv-docker-examples

Multi-stage Dockerfile with Python and `uv`. GitHub Gist: instantly share code, notes, and snippets.

December 3, 2024 - mkdir uv-docker-example && cd uv-docker-example \ && mkdir docker src && touch docker/Dockerfile docker/compose.yaml · To initialize the project, let’s start with a minimal Dockerfile.

The example below shows how to leverage uv in the Dockerfile to pre-install dependencies. FROM python:3.12-slim-bookworm COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/ WORKDIR /app COPY check_rain .

ENV UV_PYTHON_CACHE_DIR=/root/.cache/uv/python RUN --mount=type=cache,target=/root/.cache/uv \ uv python install ... The cache directory's location can be determined by running the `uv cache dir` command in the container. Alternatively, the cache can be set to a constant location: ```dockerfile title="Dockerfile" ENV UV_CACHE_DIR=/opt/uv-cache/ ```

# When prompted, or using the Command Palette (Ctrl+Shift+P), select: # > Dev Containers: Open Folder in Container (or similar) # after build you should see # CTRL+p > Python: Select Interpreter > /home/nonroot/.venv/bin/python (as defined in `Dockerfile`) Add dependencies: uv add <package-name> (runs inside the container)

September 24, 2024 - Anyways, if your application isn’t packaged for whatever reason: I have added inline notes how to adjust the Dockerfile. In a nutshell, instead of installing your application in the build step, you COPY it into the runtime container after COPYing /app over. Be careful to not overwrite /app. P.S. If you need more help with Docker, my friend Itamar Turner-Trauring has great resources for you. 2024-11-12: Added a workaround for #9046: Use absolute paths for UV_PYTHON on uv 0.5.0+.

# Install dependencies uv sync # Run tests uv run nox -s test # Format and lint uv run nox -s fmt uv run nox -s lint -- --ruff --ty · # Build the image docker build -t python-uv .

x-args: &default-args WORKSPACE_NAME: "app" UV_VER: "python3.12-bookworm" Builds and runs the application using the standard Dockerfile.

March 18, 2025 - Enter uv by Astral: a modern tool ... speed up Python dependency resolution. It introduces a fresh approach to Docker workflows, but it comes with configuration choices that may be unclear if you are not familiar with how they affect image structure. The uvGitHub repository provides three example Dockerfiles...

Using this image as a base will allow you to forget about anything required to setup uv within your Docker environment. Simply COPY your pyproject & uv lock file into your image, and uv run. See the examples folder for example usage.

name = "uv-docker-example" version = "0.1.0" description = "Add your description here" readme = "README.md" requires-python = ">=3.11" dependencies = [ "fastapi[standard]>=0.112.2", ] · [build-system] requires = ["hatchling"] build-backend = "hatchling.build" ·