before proceeding i would suggest you to go through the setup of k3s in raspberry pi
now we will create a simple flask app and create a docker image out of it
note:- (all the below code is written in your local system and deployed to raspberrypi)
first we will create a project folder
mkdir flask-project cd flask-project now inside the flask project lets create app.py and paste the following code
app.py
# app.py from flask import Flask, render_template import os app = Flask(__name__) @app.route('/') def index(): return render_template("index.html"), 200 if __name__ == "__main__": app.run(host='0.0.0.0', port=os.environ.get("PORT", 8000)) templates/index.html
# templates/index.html <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /> <title>Hello World</title> </head> <body> <h1>This is a sample flask project.</h1> </body> </html> requirements.txt
flask now lets create a Docker file for our project
FROM python:3-alpine WORKDIR /app COPY requirements.txt ./ RUN pip install --no-cache-dir -r requirements.txt COPY . . ENV PORT 80 CMD ["python", "app.py"] this is a simple docker file which runs our flask application
now we will create a simple shell script to build and push our dockerfile to dockerhub
build.sh
docker build . -t flask-starter docker tag flask-starter:latest <username>/flask-starter docker push <username>/flask-starter you can replace username with the dockerhub username
once you create the shell script run it by the following command it will push the docker image to the docker hub
sh ./build.sh # [out] in my case you can find the docker image at rohit20001221/flask-starter
pi@raspberrypi:~/starter-app-kubernetes-tutorial $ sudo sh build-docker.sh Sending build context to Docker daemon 72.19kB Step 1/7 : FROM python:3-alpine ... ... Successfully tagged flask-starter:latest Using default tag: latest The push refers to repository [docker.io/rohit20001221/flask-starter] now lets start creating out config files for our kubernetes
create a folder called k8s in your project directory
inside the k8s folder create flask-starter.yaml
flask-starter.yaml
--- apiVersion: apps/v1 kind: Deployment metadata: name: flask-starter labels: app: flask spec: replicas: 3 selector: matchLabels: app: flask template: metadata: labels: app: flask spec: containers: - name: flask-starter image: rohit20001221/flask-starter:latest ports: - containerPort: 80 --- apiVersion: v1 kind: Service metadata: name: flask-starter spec: selector: app: flask ports: - protocol: TCP port: 8080 targetPort: 80 --- apiVersion: networking.k8s.io/v1 kind: Ingress metadata: name: flask-starter-ingress spec: rules: - host: "raspberrypi.local" http: paths: - pathType: Prefix path: "/" backend: service: name: flask-starter port: number: 8080 the yaml file contains 3 parts
1. Deployment
the main purpose of deployments is to create pods and manage them
it has the following functionalities
1. creating replica set -> we can run multiple instances of our app
2. auto healing -> if any our our pod's go down the deployment will spin up new instances of our pod
as you can see in the above deployment we created 3 replica sets and assigned each replica set a label and also we have mentioned the docker hub image name to tell the deployment from where it can find our application code
2. Service
In simple words we can think of Service as a discovery server with the help of which we can access our application pod's
as you can see above we need to specify the app label which we created in the deployment in the service and also we have to specify the port number at which our application pods run
3. Ingress controller
Ingress controller exposes our application to the external world through a domain since the raspberry pi can be accessed through raspberrypi.local we will assign it as the host name
and we will define the service which we want to expose along with the port number of that service
by path: / we are telling the Ingress controller that what ever requests come to the following url http://raspberrypi.local/ we must send that request to our service flask-starter
now its time to deploy the application cd into the k8s folder
cd ./k8s and run the following command
kubectl apply -f flask-starter.yaml now our flask app is deployed to the raspberry pi you can verify by SSH'ing into the pi and running the following command
# inside raspberry pi pi@raspberrypi:~ $ sudo kubectl get pods NAME READY STATUS RESTARTS AGE flask-starter-5f5bf855dc-ljctk 1/1 Running 0 6s flask-starter-5f5bf855dc-tnzbt 1/1 Running 0 6s flask-starter-5f5bf855dc-5p86s 1/1 Running 0 6s now open your browser and type http://raspberry.local and you will see that our flask app has opened
Top comments (0)