Technology Blogs by Members
Explore a vibrant mix of technical expertise, industry insights, and tech buzz in member blogs covering SAP products, technology, and events. Get in the mix!
cancel
Showing results for 
Search instead for 
Did you mean: 
SaiNithesh_Gajula
Active Participant
2,070
Hi Everyone,

Hope everyone is doing great.

In this blog we will learn how to create small Python REST API and deploy the same to SAP BTP, Kyma Environment using Kubernetes, and Docker containerized.

There are 2 different options so far I have learned.

  1. Using GitHub Package Registry

  2. Using Docker


Pre-requisites

  1. Create SAP BTP Trial/Tier Account

  2. Enable SAP BTP Kyma Environment

  3. Git Hub Account /Docker Account – Will be used for container registry.

  4. Visual Studio (VS) Code Setup or Any IDE of your choice

  5. Python Setup

  6. Install & Set up Kubernetes

  7. Docker Desktop Set up for Mac or Windows

  8. Docker Hub (Optional)


Step 1: Now let us start creating our python application. Create a new folder, here I am naming it as py-flask-kubernetes and open the same folder in the VS Code and start running docker locally.

Step 2: Now, create Python file app.py with below code.
from flask import Flask, jsonify
import time

PORT = 8080

app = Flask(__name__)


@app.route("/")
def root():
return jsonify({"App Status" : "Running"})

@app.route("/getTime")
def getTime():
seconds = time.time()
local_time = time.localtime(seconds)
return jsonify({"Year" : local_time.tm_year,"Seconds" : seconds, "Local Time" : local_time})


if __name__ == "__main__":
app.run(debug=True, host="0.0.0.0", port=PORT)


 

Step 3: Test the python app locally using python3 app.py

Step 4: Create requirements.txt which holds the information about the dependency libraries, modules, and packages for the project.
flask

Step 5: To containerize the application lets us create Dockerfile from which generates docker image for this application.
FROM python:3.7
RUN mkdir /app
WORKDIR /app
ADD . /app/
RUN pip install -r requirements.txt
CMD ["python", "/app/app.py"]

Step 6: (Consider if you want to publish to GitHub Package Registry) Now lets us create Personal Access Token (PAT) to login to Git Account

Login to Git Hub Account => Go to Settings à Developer Settings => Personal Access Tokens (PAT).

Click on Generate new token.

Provide the token name and check repo and packages access and click on Generate Token below and token will get generated. Copy and save this token so that we will be using this in next steps

Step 7: (Consider if you want to publish to GitHub Package Registry) git login
git config --global user.name <<GitHubUserName>>
git config --global user.email <<GitHubEmailID>>
git config --global user.password <<GitHubAccessToken>>

 

Step 8: Now let’s create Kubernetes Secret Key in the SAP BTP, Kyma Environment. Make sure you have configured local workspace to BTP Kyma Environment while Kubernetes setup. Here I am going with default namespace
kubectl config set-context --current --namespace=<insert-namespace-name-here>
kubectl config view --minify | grep namespace:


GitHub Registry
kubectl create secret docker-registry py-regcred\
--namespace default \
--docker-server=ghcr.io \
--docker-email=<<GitHubEmailID>> \
--docker-username=<<GitHubUserName>> \
--docker-password=<<GitHubAccessToken>>

 

Docker Registry
kubectl create secret docker-registry regcred \
--namespace default \
--docker-server=docker.io \
--docker-email=<<DockerEmailID>> \
--docker-username=<<DockerUserName>> \
--docker-password=<<DockerPassword>>

On successful creation we can see secret key got created in the BTP Kyma Environment. To check it, open Kyma Dashboard è choose default namespace on the top right => Configuration => Secrets

Step 9: Now will generate the docker image for this app.

GitHub Registry
docker build . --tag ghcr.io/<<GITHubUserID>>/py-flask-kubernetes:latest

docker build . --tag ghcr.io/sainithesh/py-flask-kubernetes:latest
docker run ghcr.io/sainithesh/py-flask-kubernetes:latest

Docker Registry
docker build . --tag docker.io/sainithesh/py-flask-kubernetes:latest
docker run docker.io/sainithesh21/py-flask-kubernetes:latest

 

Step 10: Publish to Package Registry

GitHub Registry
docker push ghcr.io/sainithesh/py-flask-kubernetes:latest


Docker Registry
docker push docker.io/sainithesh21/py-flask-kubernetes:latest

Step 11: Now we want to deploy this containerized application which is there in the image. Create deployment.yaml with below code.

Here we must use ghcr.io if you deploy image to GitHub or use docker.io and append with image path.

image: ghcr.io/sainithesh/py-flask-kubernetes:latest

Or

image: docker.io/sainithesh/py-flask-kubernetes:latest

Service kind: Act as load balancer

Deployment kind: Act as application

API Rules: which helps in adding rules to the applications like restricting methods (GET, POST, PUT, etc), authentications and other rules.
apiVersion: apps/v1
kind: Deployment
metadata:
name: py-flask-kubernetes
labels:
app: py-flask-kubernetes
spec:
selector:
matchLabels:
app: py-flask-kubernetes
replicas: 1
template:
metadata:
labels:
app: py-flask-kubernetes
spec:
containers:
- name: py-flask-kubernetes
image: ghcr.io/sainithesh/py-flask-kubernetes:latest
imagePullPolicy: Always
ports:
- containerPort: 8080
resources:
limits:
ephemeral-storage: 256M
memory: 256M
cpu: 100m
requests:
ephemeral-storage: 256M
memory: 256M
cpu: 100m
imagePullSecrets:
- name: py-regcred
status: {}

---
apiVersion: v1
kind: Service
metadata:
name: py-flask-kubernetes
spec:
selector:
app: py-flask-kubernetes
ports:
- protocol: "TCP"
port: 8081
targetPort: 8080


---
apiVersion: gateway.kyma-project.io/v1alpha1
kind: APIRule
metadata:
name: py-flask-kubernetes
spec:
gateway: kyma-gateway.kyma-system.svc.cluster.local
service:
name: py-flask-kubernetes
port: 8081
host: py-flask-kubernetes
rules:
- path: /.*
methods: ["GET"]
accessStrategies:
- handler: noop
config: {}

 

Step 12: Deploy to Kyma Environment
kubectl apply -n default -f deployment.yaml

 

Step 13: Manual Deployment to Kyma Environment

Deployment

Workloads => Deployments => Create Deployment

Go to YAML tab and copy the deployment Code and click on Create.

Once Deployment object is created, we can see it running as below

Service: To create service for an application

Discovery and Network => Services => Create Service



API Rules:



Step 14: Pods, here we can see multiple instances for the same application which depends on the replica attribute value which is part of Service. Multiple instances here helps application to keep running even if one of the instance breaks down or crash because of any reason like heavy traffic or others.

Step 15: Service Details, here we can see the application url.



Step 16: (Consider if you published image to GitHub Registry Package) Let us push the code to the Git repo so that we can update image using GitHub Actions whenever we push new build to Git repo.

Let us create workflow file (here docker_build_and_push.yml) in the Git repo under github/workflows folder. We need to collaborate package and repo to make workflow enabled.
name: Build and Push Docker Imag

on: [push]

env:
REGISTRY: ghcr.io
IMAGE_NAME: ${{ github.repository }}

jobs:
build_and_push:
runs-on: ubuntu-latest
permissions:
contents: read
packages: write
steps:
- uses: actions/checkout@v3


- name: Set up QEMU
uses: docker/setup-qemu-action@v2

- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v2
with:
buildkitd-flags: --debug

- name: Login to GitHub Container Registry
uses: docker/login-action@v2
with:
registry: ${{ env.REGISTRY }}
username: ${{ github.actor }}
password: ${{ secrets.PKG_SECRET }}

- name: Extract metadata (tags, labels) for Docker
id: meta
uses: docker/metadata-action@v4
with:
images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}

- name: Build the py-flask-kubernetes Docker image
uses: docker/build-push-action@v3.0.0
with:
context: .
push: true
tags: ${{ steps.meta.outputs.tags }}
labels: ${{ steps.meta.outputs.labels }}

 

Step 17:  We can see all the GitHub Actions under Action Tab. On successful completion of workflow on every push to Git repo, new docker image will get updated.



Hope this blog helps you. Feel free to add comment and suggestions.

Git Repo: https://github.com/SaiNithesh/py-flask-kubernetes/

 

Regards,

Sai Nithesh
1 Comment
Labels in this area