In this step by a step blog post, that illustrates how to integrate Python Flask applications with Docker and run them in a Kubernetes cluster, we will cover the following topics: Dockerizing an existing Flask application. Deploying it using Docker Compose. Deploying to a Kubernetes cluster. Inspecting, testing, and scaling Requirements Before proceeding, make sure that your environment satisfies these requirements. Start by installing the following dependencies on your machine. Docker Kubernetes Git The Flask Application The application that we will use during this post is a simple Python application that is used as a wrapper for the weather API . The application has the following HTTP endpoints OpenWeatherMap “/”:  This is the root route and it basically responds with a static string. This endpoint can be used as a health check for the application. “/<city>/<country>”: The API endpoint used to retrieve the weather information for a given city. Both the city and the country should be provided. The complete application source code is shown below. The application simply processes the requests and forwards them to weather API endpoint then responds with the same data retrieved from the API endpoint. https://samples.openweathermap.org flask Flask requests

app = Flask(__name__)

API_KEY = @app.route( )
def index(): @app.route( )
def weather_by_city(country, city):

    url = params = dict(
        q=city + + country,
        appid= API_KEY,
    )

    response = requests.get(url=url, params=params)
    data = response.json() data __name__ == :
    app.run(host= , port= ) from import import "b6907d289e10d714a6e88b30761fae22" '/' return 'App Works!' '/<string:city>/<string:country>/' 'https://samples.openweathermap.org/data/2.5/weather' "," return if '__main__' "0.0.0.0" 5000 Dockerizing our Flask Application Dockerizing python applications is a straightforward and easy task. To do this, we need to introduce the following files to the project: The requirements files: This file contains the list of all dependencies needed by the application. For instance, one of the dependencies for our application is Flask. This file will be used to install all the defined packages during the Docker build time. Below is the content of the requirements file. certifi== chardet== Click== Flask== idna== itsdangerous== Jinja2== MarkupSafe== requests== urllib3== Werkzeug== 2019.9 .11 3.0 .4 7.0 1.1 .1 2.8 1.1 .0 2.10 .3 1.1 .1 2.22 .0 1.25 .7 0.16 .0 The Dockerfile: This file includes all the Docker instructions needed to build the Docker image of our application. As it is shown in the below file, Docker will perform the following actions to build the Docker image: Use python:3 as a base image for our application. Create the working directory inside the image and copy the requirements file. (This step helps in optimizing the Docker build time.) Install all the dependencies using pip. Copy the rest of the application files. Expose port 5000 and set the default command (CMD) for the image. FROM python: ENV PYTHONUNBUFFERED RUN mkdir /app
WORKDIR /app
COPY requirements.txt /app
RUN pip install --upgrade pip
RUN pip install -r requirements.txt
COPY . /app
EXPOSE CMD [ , ] 3 1 5000 "python" "app.py" We can now build the Docker image of our application using the below command: $> docker build -t weather:v1 .0 Running the application We can run the application locally using Docker CLI as shown below: $> docker run -dit --rm -p : --name weather weather:v1 5000 5000 .0 Or we can use a Docker Compose file to manage the build and deployment of the application in a local development environment. For instance, the below Compose file will take care of building the Docker image for the application and deploying it. version: services:
  weather:
    build: .
    ports:
      - volumes:
      - .: '3.6' "5000:5000" /app Running the application using docker-compose can be done using: $> docker-compose up Once the application is running a CURL command can be used to retrieve the weather data in London, for instance: $> curl http: //0.0.0.0:5000/london/uk/ Kubernetes Overview Running service directly with docker command or even with docker-compose is not recommended for production services because it’s not a production-ready tool. It will neither ensure that your application runs in a highly available mode nor help you to scale your application. To illustrate better the last point, Compose is limited to only one Docker host and does not support running Docker services in clusters. As a result, there is a need to use other solutions that provide such feathers. One of the most well known and used solutions is Kubernetes. This tool is an open-source project for automating deployment, scaling, and management of containerized applications. It is widely used by companies and individuals around the world for the following reasons It is free: The project is open-source and maintained by the CNCF. It is adopted by big companies such as Google, AWS, Microsoft, and many others. There are many cloud systems that offer Kubernetes managed services such as AWS, Google Cloud, and DigitalOcean. There are many plugins and tools developed by the Kubernetes community to make managing Kubernetes easier and more productive. Creating a Kubernetes Cluster for your Development Environment Kubernetes is a distributed system and integrates several components and binaries. This makes it challenging to build production clusters, at the same time running Kubernetes in a development environment will consume most of the machine resources. Furthermore, it would be difficult for developers to maintain the local cluster. This is why there is a real need to run Kubernetes locally in an easy and smooth way. A tool that should help developers keep focusing on the development and not on maintaining clusters. There are several options that can be used for achieving this task below are the top three Docker for mac: If you have a MacBook, you can install Docker for mac and enable Kubernetes from the configuration of the application as shown in the below image. You will have a Kubernetes cluster deployed locally. : Single-package fully conformant lightweight Kubernetes that work on . This can be used to run Kubernetes locally on Linux systems including Raspberry Pi. MicroK8s can be installed on CentOS using the Snap command line as shown in the below snippet Microk8s 42 flavours of Linux $> sudo yum install epel-release
$> sudo yum install snapd
$> sudo systemctl enable --now snapd.socket
$> sudo ln -s / /lib/snapd/snap /snap
$> sudo snap install microk8s --classic var In case you have a different Linux distribution you can find the instruction on the following . page :  implements a local Kubernetes cluster on macOS, Linux, and Windows that supports most of the Kubernetes features. Depending on your operation system, you can select the commands needed for installing Kubernetes from this . For instance, to install the application and start it on macOS you can use the below commands: Minikube page $> brew install minikube
$> minikube start Once Minikube, Microk8s, or Docker for Mac is installed and running, you can start using the Kubernetes command line to interact with the Kubernetes cluster. The above tools can be used easily to bootstrap a development environment and test your Kubernetes Deployments locally. However, they do not implement all features supported by Kubernetes, and not all of them are designed to support multi-node clusters. Conclusion Minikube, Microk8s, or Docker for Mac are great tools for local development. However, for testing and staging environments, highly available clusters are needed to simulate and test the application in a production-like environment. On the other hand, Running Kubernetes clusters 24/7 for the testing environment can be very expensive. You should make sure to run your cluster only when needed, shut it down when it’s no longer required, then recreate when it’s needed again. , ( : ), creating, running, terminating, and recreating clusters is easy as pie. You can . In a few minutes, your cluster is up and running, you can save its configuration, shut it down and recreate it when needed. Using Cloudplex Disclaimer The author is the Founder and CEO at Cloudplex deploy your first cluster for free In part II of this series, we are going to how to deploy our application to a Kubernetes testing cluster. We are going to create the Kubernetes Deployment for our Flask application and use Traefik to manage our Ingress and expose our application to external traffic. ( : ) Disclaimer The author is the Founder and CEO at Cloudplex

Google

Microsoft

2022 - HackerNoon Contributor of the Year - Cloud Computing

2022 - HackerNoon Contributor of the Year - Containers

2022 - HackerNoon Contributor of the Year - Developer

2022 - HackerNoon Contributor of the Year - Developer Tools

2022 - HackerNoon Contributor of the Year - Devops

2022 - HackerNoon Contributor of the Year - Docker

2022 - HackerNoon Contributor of the Year - Kubernetes

Nominated for 2022 - HackerNoon Contributor of the Year - Cloud Computing

Nominated for 2022 - HackerNoon Contributor of the Year - Developer

Nominated for 2022 - HackerNoon Contributor of the Year - Containers

Nominated for 2022 - HackerNoon Contributor of the Year - Developer Tools

Nominated for 2022 - HackerNoon Contributor of the Year - Devops

Nominated for 2022 - HackerNoon Contributor of the Year - Docker

Nominated for 2022 - HackerNoon Contributor of the Year - Kubernetes

Too Long; Didn't Read

ML Practitioners - Ready to Level Up your Skills?

Developing, Deploying and Testing Flask Applications on Kubernetes - Part I

Developing, Deploying and Testing Flask Applications on Kubernetes - Part I

Too Long; Didn't Read

Companies Mentioned

@asadfaizi

RELATED STORIES