![\"Layers](\"https:\/\/developers.redhat.com\/sites\/default\/files\/styles\/article_floated\/public\/container_layers_.png?itok=L0W6WMOn\")
<\/a>\n<\/div>\nThe repository for our recipe website application holds this Containerfile:<\/p>\n
\nFROM python\n\nLABEL maintainer=\"akeenan@redhat.com\"\n\nCOPY dependencies.txt dependencies.txt\n\nRUN pip3 install -r dependencies.txt\n\nRUN python3 -m spacy download en_core_web_sm\n\nCOPY . .\n\nCMD [\"python3\", \"-m\" , \"flask\", \"run\", \"--host=0.0.0.0\"]<\/code><\/pre>\nThe file dependencies.txt<\/code> contains the following:<\/p>\n\nflask\n\nbeautifulsoup4\n\nrequests\n\nnumpy\n\npandas\n\nclean-text\n\nspacy<\/code><\/pre>\nNext, let’s break down the Containerfile and explain why each part is necessary.<\/p>\n
FROM<\/h3>\n
FROM python<\/code><\/p>\nThe first necessary instruction for any Containerfile is FROM<\/code>. FROM<\/code> tells the container system to start a new build stage, or a new creation of an image, using the specified image as a base image.<\/p>\n#Syntax for FROM <\/code><\/p>\nFROM [--platform=] [AS ] <\/code><\/p>\nFROM [--platform=] [:] [AS ] <\/code><\/p>\nFROM [--platform=] [@] [AS ]<\/code><\/p>\nYou can use the :<\/code> to specify a specific version of an image. For example, to receive the Python version 3.9.17 image, the image argument would look like this: python:3.9.17<\/code>. Tags can be reused, so there is no guarantee the python:latest<\/code> image will be the same as python:latest<\/code> image in 2 months.<\/p>\nIf you want to ensure that you are using the same image at all times, you can specify a digest. A digest is a specific image, specified by an ID, that will not change over time. You can obtain a digest ID in the following ways:<\/p>\n
\n- By running
podman manifest inspect python:<\/code> (Figure 2)<\/li>\n- By downloading it from various image repository hubs:\n
\n- Quay<\/a><\/li>\n
- Docker Hub<\/a><\/li>\n
- Red Hat Ecosystem Catalog<\/a><\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
If a tag or digest is not specified, the :latest<\/code> tag will be used by default.<\/p>\n\n\n\n ![\"Running](\"https:\/\/developers.redhat.com\/sites\/default\/files\/styles\/article_floated\/public\/podman_digest_inspect.png?itok=UdQ-rEjC\")
<\/a>\n<\/div>\n\nFigure 2: Running the podman manifest inspect command in the CLI to get the digest ID.<\/div>\n<\/div>\n<\/article>\n<\/div>\nFROM scratch<\/h4>\n
If you do not want to use a base image\u2014perhaps you want to containerize your own underlying operating system (OS), or you have a very minimal image\u2014you have the option to use FROM scratch<\/code>. The scratch<\/code> image does not include any files or folders; instead, it tells the container system to have the next container instruction to be the first filesystem layer of the image.<\/p>\nEach base image, except for scratch<\/code>, includes an OS that it virtualizes. The default python:<\/code> image virtualizes Debian GNU\/Linux, while python:-alpine<\/code> virtualizes Alpine Linux, and python:-windowsservercore<\/code> virtualizes Windows Core OS.<\/p>\nEach operating system has a user space<\/strong> and a kernel space<\/strong>. User spaces are processes executed by a user in the operating system. The kernel space manages resources like RAM and Disk.<\/p>\nA container runs in the user space and accesses these resources by system calls. A container abstracting a certain OS will abstract the user space, and perform system calls to the host OS. In your container, the OS virtualizes Linux distributions by having their file systems packaged into a container filesystem. Sharing an underlying virtualized OS allows for a standard environment among containers.<\/p>\n
For a Python application, the Python base image works well, including all up-to-date packages you may need. FROM python<\/code> will instruct the container engine to inherit the Python base image. The Python base image will have an underlying OS, the language (Python source code, compiled), the Python runtime dependencies, and pip<\/code>.<\/p>\nIf you have a specific OS you would like to virtualize, you can inherit that base image and download Python (more on that later in this article).<\/p>\n
LABEL<\/h3>\n\nLABEL maintainer=\"akeenan@redhat.com\" <\/code><\/pre>\nA label is used for metadata about a container, using a key=value format. In this label, we use a maintainer key, with the value of. Using a maintainer reference provides a way for developers to reach out to the maintainer if they have questions or feedback about the container. It also gives you a way to take credit for your work.<\/p>\n
COPY<\/h3>\n
#Copy (local source) (destination in container) <\/code><\/p>\nCOPY dependencies.txt dependencies.txt<\/code><\/p>\nNow we have our base image and a reference to a maintainer. Our container has an owner, and the basics of the Python language.<\/p>\n
The next step is to use pip<\/code> (which is included in the Python base image) to install our dependencies. Any extra library or package a developer downloads is a dependency. In our example Python program, we imported several dependencies, including Flask, BeautifulSoup, and pandas.<\/p>\n\nfrom flask import Flask, render_template, request\n\nfrom bs4 import BeautifulSoup\n\nimport numpy as np\n\nimport pandas as pd\n\nimport spacy<\/code><\/pre>\nSteps to use the COPY<\/code> instruction:<\/p>\n\n- \n
Create a file to hold the names of all dependencies. In the sample application, it is named dependencies.txt<\/code> and looks like this:<\/p>\n\n#dependencies.txt\n\nflask\n\nbeautifulsoup4\n\nrequests\n\nnumpy\n\npandas\n\nclean-text\n\nspacy<\/code><\/pre>\n<\/li>\n<\/ol>\n\n- The instruction
COPY<\/code> will copy your dependency file from your local source into the container. If your file is under another directory, you can include the path or use the WORKDIR<\/a> instruction.<\/li>\n- Inside our local directory, the dependency file is there, named
dependencies.txt<\/code>. The instruction COPY dependencies.txt dependencies.txt<\/code> will create a new file named dependencies.txt<\/code> in your container\u00a0and copy over the contents.<\/li>\n<\/ol>\nRUN<\/h3>\n
RUN pip3 install -r dependencies.txt <\/code><\/p>\nRUN python3 -m spacy download en_core_web_sm<\/code><\/p>\nThe RUN<\/code> instruction will execute any commands needed in a new layer on top of our image.<\/p>\nWe are using Python 3, so the command in the terminal to use pip<\/code> to install <\/code> is pip3 install -r <\/code>.<\/p>\nIn our dependencies.txt<\/code> file, we have all packages and libraries that need to be downloaded using pip<\/code>. To shorten the installation process, RUN pip3 install -r dependencies.txt<\/code> will use pip<\/code> to install everything listed in our dependencies.txt<\/code> file.<\/p>\nAdditionally, for our sample program, we need to download en_core_web_sm<\/code> using the Python module space. This extra dependency is not installed using pip<\/code>, but we can use an extra RUN<\/code> command to complete the task.<\/p>\nCOPY<\/h3>\n
COPY . .<\/code><\/p>\nNow we have all dependencies downloaded using the RUN<\/code> instruction, it is time for our application files!<\/p>\nOur Containerfile is hosted in the same directory as our application files. COPY . .<\/code> copies our local directory outside of the container into the local directory inside the container.<\/p>\nCMD<\/h3>\n
CMD [\"python3\", \"-m\" , \"flask\", \"run\", \"--host=0.0.0.0\"]<\/code><\/p>\nEvery Containerfile must have one\u2014and only one\u2014CMD<\/code> instruction for the container to start. CMD<\/code> provides a default command for an executing container.<\/p>\n--host=0.0.0.0<\/code> makes a non-routable meta-address of 0.0.0.0 for the host. It means that the mapping is valid for all addresses\/interfaces of the host.<\/p>\nNormally, you would use the command python3 -m flask run<\/code> to run a Flask application. The same command is used here, in CMD [\"executable\",\"param1\",\"param2\"]<\/code><\/code> format.<\/p>\n--host=0.0.0.0<\/code> makes a non-routable meta-address of 0.0.0.0 for the host. It means that the mapping is valid for all addresses\/interfaces of the host.<\/p>\nAlternate images<\/h2>\n
While the Containerfile above includes the official\u00a0Python image, users can create a Containerfile to support Python in many different ways. Below, the first Containerfile inherits the Red Hat Enterprise Linux (RHEL)<\/a> Universal Base Image, and then installs Python. The second Containerfile inherits a base image that has combined RHEL and Python dependencies. Users can customize their Python Containerfile to work best for their\u00a0dependencies and target environment.\u00a0<\/p>\n\n#Alternate images that work!\n\n#Red Hat Enterprise Linux UBI, then installing Python\n\nFROM redhat\/ubi8\n\nLABEL maintainer=\"akeenan@redhat.com\"\n\nRUN yum -y install python39\n\nCOPY dependencies.txt dependencies.txt\n\nRUN pip3 install -r dependencies.txt\n\nRUN python3 -m spacy download en_core_web_sm\n\nCOPY . .\n\nCMD [\"python3\", \"-m\" , \"flask\", \"run\", \"--host=0.0.0.0\"]\n\nEXPOSE 5000\n<\/code><\/pre>\n\n#RHEL UBI + Python in base image\n\nFROM registry.access.redhat.com\/ubi8\/python-311:1-13\n\nLABEL maintainer=\"akeenan@redhat.com\"\n\nCOPY dependencies.txt dependencies.txt\n\nRUN pip3 install -r dependencies.txt\n\nRUN python3 -m spacy download en_core_web_sm\n\nCOPY . .\n\nCMD [\"python3\", \"-m\" , \"flask\", \"run\", \"--host=0.0.0.0\"]\n\nEXPOSE 5000<\/code><\/pre>\nBuild and run the container<\/h2>\n
Now that you’ve written your image, it’s time to build and run it. We’ll walk through a few different ways to do this.<\/p>\n
Command-line interface<\/h3>\n
In the command-line terminal, in the Containerfile directory, run:<\/p>\n
\n# should have your repo cloned\n\n# ensure you are in the files directory (Cd files)\n\npodman build --tag python-podman .\n\npodman run --publish 5000:5000 python-podman<\/code><\/pre>\npodman build --tag python-podman .<\/code> tells Podman to build the image in the current directory and name the image python-podman<\/code>.<\/p>\npodman run --publish 5000:5000 python-podman<\/code> will run the python-podman<\/code> image, and publish it on port 5000 outside of the container.<\/p>\nThe --publish<\/code> flag has syntax (outside container): (inside container)<\/code>. All Flask applications run on default port 5000, so here we connect our local host (address 127.0.0.1) port 5000 to container port 5000 on address 0.0.0.0.<\/p>\nNow, head to http:\/\/127.0.0.1:5000<\/a>, as seen in Figure 5, and enjoy your application! <\/code><\/p>\nPodman Desktop<\/h3>\n
Add to the Containerfile:<\/p>\n
\nEXPOSE 5000<\/code><\/pre>\nWhen we use the command-line interface, we force our application to be exposed on the localhost port 5000 using the command --publish 5000:5000<\/code>. On Podman Desktop, we just use the GUI, so including this line on our Containerfile will force our application to be exposed on the localhost port 5000.<\/p>\nThere are multiple ways to run a container file on Podman Desktop:<\/p>\n
\n- Build from Containerfile (Figure 3).<\/li>\n
- Build on local terminal.<\/li>\n
- Build from Quay.<\/li>\n<\/ul>\n\n
\n\n ![\"Using](\"https:\/\/developers.redhat.com\/sites\/default\/files\/styles\/article_floated\/public\/image_from_contianer_file.png?itok=uhAUCH_q\")
<\/a>\n<\/div>\n\nFigure 3: Using Podman Desktop to build a image from a Containerfile.<\/div>\n<\/div>\n<\/article>\n<\/div>\nBuild from Containerfile<\/h4>\n\n- Navigate in Podman Desktop to the Images<\/strong> tab and select Build an Image<\/strong>, as shown in Figure 4.\n
\n- Select the location of your Containerfile.<\/li>\n
- Select the location of your build directory.<\/li>\n
- Name the image.<\/li>\n
- Select Build<\/strong>, let the image build, and then select Done<\/strong>.<\/li>\n<\/ol>\n<\/li>\n
- Click the play button to start the container.\n
\n- Name the container.<\/li>\n
- Click Start<\/strong>.<\/li>\n<\/ol>\n<\/li>\n
- Visit the application by selecting the \u2026<\/strong> icon and Open in Browser<\/strong>. You will be redirected to localhost:5000, as seen in Figure 5.<\/li>\n<\/ol>\n\n
\n\n ![\"The](\"https:\/\/developers.redhat.com\/sites\/default\/files\/styles\/article_floated\/public\/nvm.png?itok=Rq8CkSBs\")
<\/a>\n<\/div>\n\nFigure 4: The Images tab in the Podman Desktop where you can pull and build images.<\/div>\n<\/div>\n<\/article>\n<\/div>\nBuild on local terminal<\/h4>\n\n- In your build context directory, run:
podman build --tag python-podman .<\/code>\n\n- In Podman Desktop, under the Images<\/strong> tab, you will have a image called
localhost\/python-podman.<\/code><\/li>\n<\/ol>\n<\/li>\n- Click the play button to start the container.\n
\n- Name the container.<\/li>\n
- Click Start<\/strong>.<\/li>\n<\/ol>\n<\/li>\n
- Visit the application by selecting the \u2026<\/strong> icon and Open in Browser<\/strong>. You will be redirected to localhost:5000, as seen in Figure 5.<\/li>\n<\/ol>\n
Build from Quay (or another image repository)<\/h4>\n
If you need to set up your Quay repository, refer to the instructions in\u00a0this guide<\/a>.\u00a0<\/p>\n\n- In Podman Desktop, under the Images<\/strong> tab, select the Pull an Image<\/strong> icon, as shown in Figure 4.\n
\n- Enter the name of your image. It will look like this:
quay.io\/\/\/<\/code><\/li>\n- Pull the image.<\/li>\n<\/ol>\n<\/li>\n
- Click the play button to start the container.\n
\n- Name the container.<\/li>\n
- Click Start<\/strong>.<\/li>\n<\/ol>\n<\/li>\n
- Visit the application by selecting the \u2026<\/strong> icon and Open in Browser<\/strong>. You will be redirected to localhost:5000, as seen in Figure 5.<\/li>\n<\/ol>\n
![\"The](\"https:\/\/developers.redhat.com\/sites\/default\/files\/styles\/article_floated\/public\/recipe_app_norm.png?itok=DVAOA6zz\")
<\/a>\n<\/div>\n