Detailed steps for building, running, publishing, and obtaining a Docker image for the first time

1. Introduction

In the past, if you wanted to start writing Python applications, the first step was to install the Python runtime environment on your machine, and the installed environment had to be consistent with the online one, which was quite troublesome.

Using Docker, you can get a portable Python runtime environment image from the official Docker registry or other repositories without installation. You can then develop your application based on this image, which ensures that your application, dependencies, and runtime all run together.

2. Build a Python image

2.1. To build your own image, you first need to create a file named Dockerfile to define the steps required to create an image and run a container. Each instruction in a Dockerfile creates a layer in the image. When you change your Dockerfile and rebuild the image, only those layers that changed are rebuilt. This is one of the reasons that makes images lightweight, small, and fast compared to other virtualization technologies.

Create an empty directory, create a file called Dockerfile, copy and paste the following content into the file and save it.

# Use an official Python runtime as a parent image
FROM python:2.7-slim
# Set the working directory to /app
WORKDIR /app
# Copy the current directory contents into the container at /app
ADD ./app
# Install any needed packages specified in requirements.txt
RUN pip install --trusted-host pypi.python.org -r requirements.txt
# Make port 80 available to the world outside this container
EXPOSE 80
# Define environment variable
ENV NAME World
# Run app.py when the container launches
CMD ["python", "app.py"]

2.2 Create requirements.txt and app.py files in the same directory as the Dockerfile file. Because of the ADD command in the Dockerfile file, the above two files will be added to the final image; because of the EXPOSE command, the content of app.py can be accessed by accessing port 80 of the container. Note: port 80 here refers to the port exposed by the container, not the port of the actual machine.
requirements.txt

Flask
Redis

app.py

from flask import Flask
from redis import Redis, RedisError
import os
import socket
# Connect to Redis
redis = Redis(host="redis", db=0, socket_connect_timeout=2, socket_timeout=2)
app = Flask(__name__)
@app.route("/")
def hello():
  try:
    visits = redis.incr("counter")
  except RedisError:
    visits = "<i>cannot connect to Redis, counter disabled</i>"
  html = "<h3>Hello {name}!</h3>" \
      "<b>Hostname:</b> {hostname}<br/>" \
      "<b>Visits:</b> {visits}"
  return html.format(name=os.getenv("NAME", "world"), hostname=socket.gethostname(), visits=visits)
if __name__ == "__main__":
  app.run(host='0.0.0.0', port=80)

2.3 Package our application into a mirror and execute it in the DockerFile directory. This will create a Docker image, which we will tag with -t so that the image has a friendly name.

docker build -t friendlyhello

3. Run the image

Run the application, using -p to map port 4000 on your machine to port 80 exposed by the container:

docker run -p 4000:80 friendlyhello 

You can also use the curl command in the shell to see the same content.

$ curl http://localhost:4000
<h3>Hello World!</h3><b>Hostname:</b> 8fc990912a14<br/><b>Visits:</b> <i>cannot connect to Redis, counter disabled</i>

Press Ctrl+C to end the application

Now let's run the application in the background:

docker run -d -p 4000:80 friendlyhello

View all container information

$ docker container ls
CONTAINER ID IMAGE COMMAND CREATED
1fa4ab2cf395 friendlyhello "python app.py" 28 seconds ago

Now use docker container stop to end the process, using the CONTAINER ID, as shown below:

docker container stop 1fa4ab2cf395

4. Release the image

4.1. I use Alibaba Cloud's Docker registry, which I think should be faster. First, you need to have an Alibaba Cloud account. Then log in to create a new warehouse and set the namespace and other information.

4.2 Log in to Alibaba Cloud's Docker registry. Subsequent operations require logging in to perform.

sudo docker login --username=admin registry.cn-hangzhou.aliyuncs.com

4.3 Tag the image. Tag is optional. If not, the default is latest.

Format:

docker tag image_name registry_url/namespace/repository_name:[tag]

For example

docker tag friendlyhello registry.cn-hangzhou.aliyuncs.com/shuzhou/demo1:latest

View the local mirror list

docker image ls

4.4 Release the image

docker push registry.cn-hangzhou.aliyuncs.com/shuzhou/demo1:latest

4.5 Now you can execute the following command on any machine to run the image

docker run -p 4000:80 registry.cn-hangzhou.aliyuncs.com/shuzhou/demo1:latest

4.6 Pull the image

docker pull registry.cn-hangzhou.aliyuncs.com/shuzhou/demo1:latest

Summarize

The above is the full content of this article. I hope that the content of this article will have certain reference learning value for your study or work. Thank you for your support of 123WORDPRESS.COM. If you want to learn more about this, please check out the following links