One of the hardest problems that new programmers face is understanding the concept of an ‘environment’. An environment is what you could say, the system that you code within. In principal it sounds easy, but later on in your career you begin to understand just how difficult it is to maintain.

新程序員面臨的最困難的問題之一是了解“環境”的概念。 您可以說的是環境，即您在其中編碼的系統。 從原則上講，這聽起來很容易，但是在職業生涯的后期，您開始了解維護的難易程度。

The reason being is that libraries and IDE’s and even the Python Code itself goes through updates and version changes, then sometimes, you’ll update one library, and a separate piece of code will fail, so you’ll need to go back and fix it.

原因是庫和IDE甚至Python代碼本身都會進行更新和版本更改，因此有時您將更新一個庫，而另一段代碼將失敗，因此您需要返回并進行修復它。

Moreover, if we have multiple projects being developed at the same time, there can be dependency conflicts, which is when things really get ugly as code fails directly because of another piece of code.

而且，如果我們同時開發多個項目，則可能存在依賴沖突，這是當代碼由于另一段代碼而直接失敗時，事情變得非常難看。

Also, say you want to share a project to a team mate working on a different OS, or even ship your project that you’ve built on your Mac to a production server on a different OS, would you have to reconfigure your code? Yes, you probably will have to.

另外，假設您想與在不同OS上工作的團隊共享一個項目，或者甚至將在Mac上構建的項目運送到在不同OS上的生產服務器上，是否需要重新配置代碼？ 是的，您可能必須這樣做。

So to mitigate any of these issues, containers were proposed as a method to separate projects and the environments that they exist within. A container is basically a place where an environment can run, separate to everything else on the system. Once you define what’s in your container, it becomes so much easier to recreate the environment, and even share the project with teammates.

因此，為了緩解這些問題中的任何一個，提出了將containers作為一種將項目及其所處環境分開的方法。 一個 container 基本上是一個可以運行環境的地方，與系統上的所有其他地方分開。 一旦定義了container,中的container,就可以輕松地重新創建環境，甚至與隊友共享項目。

要求 (Requirements)

To get started, we need to install a few things to get set up:

首先，我們需要安裝一些東西進行設置：

• Windows or macOS: Install Docker Desktop

  Windows或macOS： 安裝Docker桌面

• Linux: Install Docker and then Docker Compose

  Linux：先安裝Docker ，再安裝Docker Compose

容器化Python服務 (Containerise a Python service)

Let’s imagine we’re creating a Flask service called server.py and let’s say the contents of the file are as follows:

假設我們正在創建一個名為server.py的Flask服務，并假設文件的內容如下：

from flask import Flask
server = Flask(__name__)@server.route("/")
 def hello():
    return "Hello World!"if __name__ == "__main__":
   server.run(host='0.0.0.0')

Now as I said above, we need to keep a record of the dependencies for our code so for this, we can create a requirements.txt file that can contain the following requirement:

現在，如上所述，我們需要記錄代碼的依賴關系，因此，我們可以創建一個requirements.txt文件，其中可以包含以下要求：

Flask==1.1.1

So our package has the following structure:

因此，我們的軟件包具有以下結構：

app
├─── requirements.txt
└─── src
     └─── server.py

The structure is pretty logical (source kept is kept in a separate directory). To execute our Python program, all is left to do is to install a Python interpreter and run it.

該結構非常合理(源代碼保存在單獨的目錄中)。 要執行我們的Python程序，剩下要做的就是安裝一個Python解釋器并運行它。

Now to run the program, we could run it locally but suppose we have 15 projects we’re working through — it makes sense to run it in a container to avoid any conflicts with any other projects.

現在要運行該程序，我們可以在本地運行它，但假設我們正在處理15個項目-在容器中運行它以避免與任何其他項目發生任何沖突都是有意義的。

Let’s move onto containerisation.

讓我們進入集裝箱化。

Docker文件 (Dockerfile)

To run Python code, we pack the container as a Docker image and then run a container based on it. So as follows:

要運行Python代碼，我們將容器打包為Docker image ，然后基于該容器運行一個容器。 因此如下：

1. Create a Dockerfile that contains instructions needed to build the image
   創建一個Dockerfile，其中包含構建映像所需的指令

2. Then create an image by the Docker builder

   然后通過Docker構建器創建image

3. The simple docker run <image> command then creates a container that is running an app

   簡單的docker run <image>命令然后創建一個運行應用程序的容器

Dockerfile的分析 (Analysis of a Dockerfile)

A Dockerfile is a file that contains instructions for assembling a Docker image (saved as myimage):

Dockerfile是一個文件，其中包含有關組裝Docker映像(保存為myimage )的說明：

# set base image (host OS)
FROM python:3.8# set the working directory in the container
WORKDIR /code# copy the dependencies file to the working directory
COPY requirements.txt .# install dependencies
RUN pip install -r requirements.txt# copy the content of the local src directory to the working directory
COPY src/ .# command to run on container start
CMD [ "python", "./server.py" ]

A Dockerfile is compiled line by line so the builder generates an image layer and stacks it upon previous images.

Dockerfile是逐行編譯的，因此構建器會生成圖像層并將其堆疊在先前的圖像上。

We can also observe in the output of the build command the Dockerfile instructions being executed as steps.

我們還可以在build命令的輸出中觀察到作為步驟執行的Dockerfile指令。

$ docker build -t myimage .
Sending build context to Docker daemon 6.144kBStep 1/6 : FROM python:3.8
3.8.3-alpine: Pulling from library/python
…
Status: Downloaded newer image for python:3.8.3-alpine
---> 8ecf5a48c789Step 2/6 : WORKDIR /code
---> Running in 9313cd5d834d
Removing intermediate container 9313cd5d834d
---> c852f099c2f9Step 3/6 : COPY requirements.txt .
---> 2c375052ccd6Step 4/6 : RUN pip install -r requirements.txt
---> Running in 3ee13f767d05
…
Removing intermediate container 3ee13f767d05
---> 8dd7f46dddf0Step 5/6 : COPY ./src .
---> 6ab2d97e4aa1Step 6/6 : CMD python server.py
---> Running in fbbbb21349be
Removing intermediate container fbbbb21349be
---> 27084556702b
Successfully built 70a92e92f3b5
Successfully tagged myimage:latest

Then, we can see that the image is in the local image store:

然后，我們可以看到該圖像在本地圖像存儲中：

$ docker images
REPOSITORY    TAG       IMAGE ID        CREATED          SIZE
myimage       latest    70a92e92f3b5    8 seconds ago    991MB

During development, we may need to rebuild the image for our Python service multiple times and we want this to take as little time as possible.

在開發過程中，我們可能需要多次重建Python服務的映像，并且我們希望這樣做花費盡可能少的時間。

Note: Docker and virtualenv are quite similar but different. Virtualenv only allows you to switch between Python Dependencies but you’re stuck with your host OS. However with Docker, you can swap out the entire OS — install and run Python on any OS (think Ubuntu, Debian, Alpine, even Windows Server Core). Therefore if you work in a team and want to future proof your technology, use Docker. If you don’t care about it — venv is fine, but remember it’s not future proof. Please reference this if you still want more information.

注意： Docker和virtualenv非常相似，但有所不同。 Virtualenv只允許您在Py??thon依賴關系之間進行切換，但是您對主機OS感到Virtualenv 。 但是，使用Docker ，您可以換出整個OS -在任何OS上安裝并運行Python(請考慮使用Ubuntu，Debian，Alpine甚至Windows Server Core)。 因此，如果您在團隊中工作，并且希望將來驗證您的技術，請使用Docker 。 如果您不關心它， venv很好，但是請記住，這并不是未來的證明。 如果您仍需要更多信息，請參考此內容。

There you have it! We’ve shown how to containerise a Python service. Hopefully, this process will make it a lot easier and gives your project a longer shelf life as it’ll be less likely to come down with code-bugs as dependencies change.

你有它！ 我們已經展示了如何容器化Python服務。 希望這個過程將使它變得更容易，并為您的項目提供更長的保存期限，因為隨著依賴關系的改變，代碼錯誤的可能性將降低。

Thanks for reading, and please let me know if you have any questions!

感謝您的閱讀，如果您有任何疑問，請告訴我！

Keep up to date with my latest articles here!

在這里了解我的最新文章！