Python dockerfile tutorial

Paula 145 Published: 09/25/2024

Python dockerfile tutorial

I'd be happy to provide a Python Dockerfile tutorial for you.

What is Docker?

Docker is a containerization platform that allows you to package, ship, and run applications in containers. Containers are lightweight and portable, making them ideal for developing, testing, and deploying applications efficiently. In this tutorial, we'll use Docker to create a container for running Python applications.

Creating a Dockerfile

A Dockerfile is a text file that contains instructions for creating an image. To start, create a new file named Dockerfile in your project directory:

# Use an official Python runtime as the base image

FROM python:3.9-slim

Set the working directory to /app

WORKDIR /app

Copy the requirements file

COPY requirements.txt .

Install the dependencies

RUN pip install -r requirements.txt

Copy the application code

COPY . .

Make port 80 available to the world outside this container

EXPOSE 80

Run the command when the container is run

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

Let's go through each line:

FROM python:3.9-slim: We're using the official Python 3.9 runtime as our base image, with a slim variant to reduce the image size. WORKDIR /app: We set the working directory inside the container to /app. COPY requirements.txt .: We copy the requirements.txt file from our local machine into the container. RUN pip install -r requirements.txt: We run a command that installs all the dependencies specified in requirements.txt using pip. COPY . .: We copy all the files from our local machine into the container, excluding requirements.txt. EXPOSE 80: We make port 80 available to the world outside this container, so we can access it from a web browser or other applications. CMD ["python", "app.py"]: When the container is run, this command tells Docker what command to execute. In this case, we're running the Python interpreter with our application code.

Building and Running the Image

To build the image, navigate to your project directory and run:

docker build -t my-python-app .

This will create an image named my-python-app based on our Dockerfile. To run the container, use:

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

This will start a new container from the my-python-app image and map port 8000 on your local machine to port 80 in the container.

Accessing Your Application

Now you can access your application by visiting http://localhost:8000 in your web browser. You should see the output of your Python script.

That's it! With these steps, you've created a Docker image for running Python applications. This tutorial has shown you how to:

Create a Dockerfile Build and run an image using the Docker command-line tool Access your application from outside the container

In future tutorials, we'll explore more advanced Docker concepts, such as mounting volumes, linking containers, and using Docker Compose to manage multiple services.

Python dockerfile github

Here's a comprehensive overview of using Python, Docker, and GitHub together:

Python

Python is a popular programming language known for its simplicity, readability, and large standard library. It's widely used in various domains such as web development, scientific computing, data analysis, artificial intelligence, and more.

Docker

Docker is an open-source containerization platform that allows you to package, ship, and run applications in containers. Containers provide a lightweight and portable way to deploy applications, ensuring consistency across environments. Docker uses Linux kernel features to create isolated environments for your applications, making it easy to manage dependencies and ensure reproducibility.

Building a Python Docker Image

To build a Python Docker image, you'll need to:

Create a Dockerfile in the root directory of your project with the following content: 
FROM python:3.9-slim

WORKDIR /app


COPY requirements.txt .


RUN pip install --no-cache-dir -r requirements.txt


COPY . .


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

Here's a breakdown:

FROM python:3.9-slim specifies the base image as Python 3.9 with a slim profile. WORKDIR /app sets the working directory to /app. COPY requirements.txt . copies your requirements.txt file into the container. RUN pip install --no-cache-dir -r requirements.txt installs dependencies listed in requirements.txt without caching. COPY . . copies your project code into the container. CMD ["python", "app.py"] sets the default command to run when you start the container.

Using GitHub

GitHub is a web-based platform for version control and collaboration. You can use GitHub to:

Store your Dockerfile and Python code in a repository. Collaborate with others on your project. Version control your changes.

To use GitHub, follow these steps:

Create a new GitHub repository for your project. Initialize a Git repository locally using git init. Add your files to the Git repository using git add .. Commit your changes using git commit -m "Initial commit" . Push your changes to the remote repository using git push origin master.

Example Workflow

Here's an example workflow that demonstrates how you can use Python, Docker, and GitHub together:

Create a new GitHub repository for your project. Initialize a Git repository locally using git init. Write your Python code in a file named app.py . Create a Dockerfile with the content above. Run docker build -t mypythonapp . to build the Docker image. Push your changes to the remote repository using git push origin master. Share your Docker image on Docker Hub or another container registry.

Conclusion

Using Python, Docker, and GitHub together allows you to create a portable, scalable, and maintainable application that can be easily shared with others. By following this example workflow, you can build a robust development environment that streamlines the process of writing, testing, and deploying your code.

Related Articles