mirror of https://github.com/docker/docs.git
380 lines
8.9 KiB
Markdown
380 lines
8.9 KiB
Markdown
---
|
|
title: Containerize a Python application
|
|
linkTitle: Containerize your app
|
|
weight: 10
|
|
keywords: python, flask, containerize, initialize
|
|
description: Learn how to containerize a Python application.
|
|
aliases:
|
|
- /language/python/build-images/
|
|
- /language/python/run-containers/
|
|
- /language/python/containerize/
|
|
- /guides/language/python/containerize/
|
|
---
|
|
|
|
## Prerequisites
|
|
|
|
- You have installed the latest version of [Docker Desktop](/get-started/get-docker.md).
|
|
- You have a [git client](https://git-scm.com/downloads). The examples in this section use a command-line based git client, but you can use any client.
|
|
|
|
## Overview
|
|
|
|
This section walks you through containerizing and running a Python application.
|
|
|
|
## Get the sample application
|
|
|
|
The sample application uses the popular [FastAPI](https://fastapi.tiangolo.com) framework.
|
|
|
|
Clone the sample application to use with this guide. Open a terminal, change directory to a directory that you want to work in, and run the following command to clone the repository:
|
|
|
|
```console
|
|
$ git clone https://github.com/estebanx64/python-docker-example
|
|
```
|
|
|
|
## Initialize Docker assets
|
|
|
|
Now that you have an application, you can create the necessary Docker assets to
|
|
containerize your application. You can use Docker Desktop's built-in Docker Init
|
|
feature to help streamline the process, or you can manually create the assets.
|
|
|
|
{{< tabs >}}
|
|
{{< tab name="Use Docker Init" >}}
|
|
|
|
Inside the `python-docker-example` directory, run the `docker init` command. `docker
|
|
init` provides some default configuration, but you'll need to answer a few
|
|
questions about your application. For example, this application uses FastAPI to
|
|
run. Refer to the following example to answer the prompts from `docker init` and
|
|
use the same answers for your prompts.
|
|
|
|
```console
|
|
$ docker init
|
|
Welcome to the Docker Init CLI!
|
|
|
|
This utility will walk you through creating the following files with sensible defaults for your project:
|
|
- .dockerignore
|
|
- Dockerfile
|
|
- compose.yaml
|
|
- README.Docker.md
|
|
|
|
Let's get started!
|
|
|
|
? What application platform does your project use? Python
|
|
? What version of Python do you want to use? 3.11.4
|
|
? What port do you want your app to listen on? 8000
|
|
? What is the command to run your app? python3 -m uvicorn app:app --host=0.0.0.0 --port=8000
|
|
```
|
|
|
|
Create a file named `.gitignore` with the following contents.
|
|
|
|
```text {collapse=true,title=".gitignore"}
|
|
# Byte-compiled / optimized / DLL files
|
|
__pycache__/
|
|
*.py[cod]
|
|
*$py.class
|
|
|
|
# C extensions
|
|
*.so
|
|
|
|
# Distribution / packaging
|
|
.Python
|
|
build/
|
|
develop-eggs/
|
|
dist/
|
|
downloads/
|
|
eggs/
|
|
.eggs/
|
|
lib/
|
|
lib64/
|
|
parts/
|
|
sdist/
|
|
var/
|
|
wheels/
|
|
share/python-wheels/
|
|
*.egg-info/
|
|
.installed.cfg
|
|
*.egg
|
|
MANIFEST
|
|
|
|
# Unit test / coverage reports
|
|
htmlcov/
|
|
.tox/
|
|
.nox/
|
|
.coverage
|
|
.coverage.*
|
|
.cache
|
|
nosetests.xml
|
|
coverage.xml
|
|
*.cover
|
|
*.py,cover
|
|
.hypothesis/
|
|
.pytest_cache/
|
|
cover/
|
|
|
|
# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
|
|
__pypackages__/
|
|
|
|
# Environments
|
|
.env
|
|
.venv
|
|
env/
|
|
venv/
|
|
ENV/
|
|
env.bak/
|
|
venv.bak/
|
|
```
|
|
|
|
{{< /tab >}}
|
|
{{< tab name="Manually create assets" >}}
|
|
|
|
If you don't have Docker Desktop installed or prefer creating the assets
|
|
manually, you can create the following files in your project directory.
|
|
|
|
Create a file named `Dockerfile` with the following contents.
|
|
|
|
```dockerfile {collapse=true,title=Dockerfile}
|
|
# syntax=docker/dockerfile:1
|
|
|
|
# Comments are provided throughout this file to help you get started.
|
|
# If you need more help, visit the Dockerfile reference guide at
|
|
# https://docs.docker.com/go/dockerfile-reference/
|
|
|
|
# Want to help us make this template better? Share your feedback here: https://forms.gle/ybq9Krt8jtBL3iCk7
|
|
|
|
ARG PYTHON_VERSION=3.11.4
|
|
FROM python:${PYTHON_VERSION}-slim AS base
|
|
|
|
# Prevents Python from writing pyc files.
|
|
ENV PYTHONDONTWRITEBYTECODE=1
|
|
|
|
# Keeps Python from buffering stdout and stderr to avoid situations where
|
|
# the application crashes without emitting any logs due to buffering.
|
|
ENV PYTHONUNBUFFERED=1
|
|
|
|
WORKDIR /app
|
|
|
|
# Create a non-privileged user that the app will run under.
|
|
# See https://docs.docker.com/go/dockerfile-user-best-practices/
|
|
ARG UID=10001
|
|
RUN adduser \
|
|
--disabled-password \
|
|
--gecos "" \
|
|
--home "/nonexistent" \
|
|
--shell "/sbin/nologin" \
|
|
--no-create-home \
|
|
--uid "${UID}" \
|
|
appuser
|
|
|
|
# Download dependencies as a separate step to take advantage of Docker's caching.
|
|
# Leverage a cache mount to /root/.cache/pip to speed up subsequent builds.
|
|
# Leverage a bind mount to requirements.txt to avoid having to copy them into
|
|
# into this layer.
|
|
RUN --mount=type=cache,target=/root/.cache/pip \
|
|
--mount=type=bind,source=requirements.txt,target=requirements.txt \
|
|
python -m pip install -r requirements.txt
|
|
|
|
# Switch to the non-privileged user to run the application.
|
|
USER appuser
|
|
|
|
# Copy the source code into the container.
|
|
COPY . .
|
|
|
|
# Expose the port that the application listens on.
|
|
EXPOSE 8000
|
|
|
|
# Run the application.
|
|
CMD python3 -m uvicorn app:app --host=0.0.0.0 --port=8000
|
|
```
|
|
|
|
Create a file named `compose.yaml` with the following contents.
|
|
|
|
```yaml {collapse=true,title=compose.yaml}
|
|
# Comments are provided throughout this file to help you get started.
|
|
# If you need more help, visit the Docker Compose reference guide at
|
|
# https://docs.docker.com/go/compose-spec-reference/
|
|
|
|
# Here the instructions define your application as a service called "server".
|
|
# This service is built from the Dockerfile in the current directory.
|
|
# You can add other services your application may depend on here, such as a
|
|
# database or a cache. For examples, see the Awesome Compose repository:
|
|
# https://github.com/docker/awesome-compose
|
|
services:
|
|
server:
|
|
build:
|
|
context: .
|
|
ports:
|
|
- 8000:8000
|
|
```
|
|
|
|
Create a file named `.dockerignore` with the following contents.
|
|
|
|
```text {collapse=true,title=".dockerignore"}
|
|
# Include any files or directories that you don't want to be copied to your
|
|
# container here (e.g., local build artifacts, temporary files, etc.).
|
|
#
|
|
# For more help, visit the .dockerignore file reference guide at
|
|
# https://docs.docker.com/go/build-context-dockerignore/
|
|
|
|
**/.DS_Store
|
|
**/__pycache__
|
|
**/.venv
|
|
**/.classpath
|
|
**/.dockerignore
|
|
**/.env
|
|
**/.git
|
|
**/.gitignore
|
|
**/.project
|
|
**/.settings
|
|
**/.toolstarget
|
|
**/.vs
|
|
**/.vscode
|
|
**/*.*proj.user
|
|
**/*.dbmdl
|
|
**/*.jfm
|
|
**/bin
|
|
**/charts
|
|
**/docker-compose*
|
|
**/compose.y*ml
|
|
**/Dockerfile*
|
|
**/node_modules
|
|
**/npm-debug.log
|
|
**/obj
|
|
**/secrets.dev.yaml
|
|
**/values.dev.yaml
|
|
LICENSE
|
|
README.md
|
|
```
|
|
|
|
Create a file named `.gitignore` with the following contents.
|
|
|
|
```text {collapse=true,title=".gitignore"}
|
|
# Byte-compiled / optimized / DLL files
|
|
__pycache__/
|
|
*.py[cod]
|
|
*$py.class
|
|
|
|
# C extensions
|
|
*.so
|
|
|
|
# Distribution / packaging
|
|
.Python
|
|
build/
|
|
develop-eggs/
|
|
dist/
|
|
downloads/
|
|
eggs/
|
|
.eggs/
|
|
lib/
|
|
lib64/
|
|
parts/
|
|
sdist/
|
|
var/
|
|
wheels/
|
|
share/python-wheels/
|
|
*.egg-info/
|
|
.installed.cfg
|
|
*.egg
|
|
MANIFEST
|
|
|
|
# Unit test / coverage reports
|
|
htmlcov/
|
|
.tox/
|
|
.nox/
|
|
.coverage
|
|
.coverage.*
|
|
.cache
|
|
nosetests.xml
|
|
coverage.xml
|
|
*.cover
|
|
*.py,cover
|
|
.hypothesis/
|
|
.pytest_cache/
|
|
cover/
|
|
|
|
# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
|
|
__pypackages__/
|
|
|
|
# Environments
|
|
.env
|
|
.venv
|
|
env/
|
|
venv/
|
|
ENV/
|
|
env.bak/
|
|
venv.bak/
|
|
```
|
|
|
|
{{< /tab >}}
|
|
{{< /tabs >}}
|
|
|
|
You should now have the following contents in your `python-docker-example`
|
|
directory.
|
|
|
|
```text
|
|
├── python-docker-example/
|
|
│ ├── app.py
|
|
│ ├── requirements.txt
|
|
│ ├── .dockerignore
|
|
│ ├── .gitignore
|
|
│ ├── compose.yaml
|
|
│ ├── Dockerfile
|
|
│ └── README.md
|
|
```
|
|
|
|
To learn more about the files, see the following:
|
|
|
|
- [Dockerfile](/reference/dockerfile.md)
|
|
- [.dockerignore](/reference/dockerfile.md#dockerignore-file)
|
|
- [.gitignore](https://git-scm.com/docs/gitignore)
|
|
- [compose.yaml](/reference/compose-file/_index.md)
|
|
|
|
## Run the application
|
|
|
|
Inside the `python-docker-example` directory, run the following command in a
|
|
terminal.
|
|
|
|
```console
|
|
$ docker compose up --build
|
|
```
|
|
|
|
Open a browser and view the application at [http://localhost:8000](http://localhost:8000). You should see a simple FastAPI application.
|
|
|
|
In the terminal, press `ctrl`+`c` to stop the application.
|
|
|
|
### Run the application in the background
|
|
|
|
You can run the application detached from the terminal by adding the `-d`
|
|
option. Inside the `python-docker-example` directory, run the following command
|
|
in a terminal.
|
|
|
|
```console
|
|
$ docker compose up --build -d
|
|
```
|
|
|
|
Open a browser and view the application at [http://localhost:8000](http://localhost:8000).
|
|
|
|
To see the OpenAPI docs you can go to [http://localhost:8000/docs](http://localhost:8000/docs).
|
|
|
|
You should see a simple FastAPI application.
|
|
|
|
In the terminal, run the following command to stop the application.
|
|
|
|
```console
|
|
$ docker compose down
|
|
```
|
|
|
|
For more information about Compose commands, see the [Compose CLI
|
|
reference](/reference/cli/docker/compose/_index.md).
|
|
|
|
## Summary
|
|
|
|
In this section, you learned how you can containerize and run your Python
|
|
application using Docker.
|
|
|
|
Related information:
|
|
|
|
- [Docker Compose overview](/manuals/compose/_index.md)
|
|
|
|
## Next steps
|
|
|
|
In the next section, you'll learn how you can develop your application using
|
|
containers.
|