Welcome to a comprehensive workshop on deploying Kubernetes services and utilizing an Ambassador API Gateway. In this guide, we’ll explore how to set up a simple Python Flask application that returns a list of trending GitHub repositories by programming language. Let’s dive into the essentials of Kubernetes and Docker, and then tackle any roadblocks you may encounter along the way!

Table of Contents

• Introduction
• Development Environment
• Developing a Trending Git Repositories API (Flask)
• Pushing the Image to a Remote Registry
• A Security Notice
• Installing Minikube
• Deploying to Kubernetes
• Services
• Inconvenience of Load Balancer Service
• An API Gateway
• Edge Proxy vs Service Mesh
• Accessing the Kubernetes API
• Using an API Client
• Accessing the API from inside a POD
• Star History
• Thanks to all the contributors!

Introduction

In this workshop, you will learn how to deploy Kubernetes services, set up an Ambassador API gateway, access the Kubernetes API, and identify the right API for your needs – all by developing a simple Flask API!

Development Environment

Ensure your environment is equipped with Python 3.6.7, preferably on Ubuntu 18.04. If necessary, follow these commands to install Python:

sudo apt-get install python3.6

Next, install PIP and Virtualenvwrapper to manage your Python environments:

sudo apt-get install python3-pip
sudo pip3 install virtualenvwrapper

Create and activate your new virtual environment and install Flask:

mkvirtualenv --python=usrbinpython3 trendinggitrepositories
workon trendinggitrepositories
pip install flask

Developing a Trending Git Repositories API (Flask)

Now, let’s create the Flask application. Consider this code as setting up a greeting booth:

from flask import Flask
app = Flask(__name__)

@app.route("/")
def index():
    return "Hello, World!"

if __name__ == "__main__":
    app.run(debug=True)

This application, once run, returns a friendly “Hello, World!” message to visitors. Think of it as opening the door to our booth.

Pushing the Image to a Remote Registry

We need our built images to be accessible beyond our local environment, hence pushing them to a Docker registry like Dockerhub. Create an account on Dockerhub and log in:

docker login

Rebuild the image with a new tag, then push it using:

docker build -t username/image_name:tag_version .
docker push username/image_name:tag_version

A Security Notice

Ensure to use a .dockerignore file to prevent sensitive data like tokens from being uploaded:

**.git**
**.gitignore**
**README.md**
.env
.Dockerfile

Installing Minikube

Minikube allows you to create a local Kubernetes cluster. First, confirm virtualization support on your laptop. Install Minikube using:

curl -Lo minikube https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
chmod +x minikube
sudo install minikube /usr/local/bin

Deploying to Kubernetes

To deploy your application on Kubernetes, create a deployment YAML file. Here’s a simplified example, resembling establishing the guidelines for your booth’s layout:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tgr
spec:
  replicas: 1
  selector:
    matchLabels:
      name: tgr
  template:
    metadata:
      labels:
        name: tgr
    spec:
      containers:
      - name: tgr
        image: username/tgr:1
        ports:
        - containerPort: 5000

Services

To connect the booth (service) to the outside world, we can create a LoadBalancer service. Here’s the YAML configuration for it:

apiVersion: v1
kind: Service
metadata:
  name: lb
spec:
  ports:
  - port: 80
    targetPort: 5000
  selector:
    name: tgr
  type: LoadBalancer

Inconvenience of Load Balancer Service

Running multiple services leads to excessive costs with a load balancer for each. Consider using an Ingress controller instead for efficient traffic management.

An API Gateway

Utilize Ambassador as your API gateway, streamlining your services in a Kubernetes cluster without needing multiple load balancers:

apiVersion: v1
kind: Service
metadata:
  name: ambassador
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 8080
  selector:
    service: ambassador

Edge Proxy vs Service Mesh

Remember, Ambassador manages incoming traffic while tools like Istio manage service-to-service traffic. It’s important to utilize these tools effectively as part of your API architecture.

Accessing the Kubernetes API

Access the Kubernetes API directly by creating a proxy. This is akin to setting up a direct connection to your booth’s info desk:

kubectl proxy --port=8080

Using an API Client

Install the Kubernetes client library to interact with the Kubernetes API using Python:

pip install kubernetes

Accessing the API from inside a POD

Every pod has its own environment settings, including service accounts that confer certain permissions. Make sure these roles are defined using RBAC so they can communicate as required.

Star History

Share your achievements and contributions through popular coding platforms like GitHub. Engage the wider community!

Thanks to all the contributors!

Thank you for participating in this journey into Kubernetes! We hope you found this guide beneficial.

Troubleshooting:

If you encounter issues, check your configurations and environment variables. Make sure your Docker images are built correctly without sensitive info. For persistent problems, confirm that your Minikube and kubectl are up to date. For more insights, updates, or to collaborate on AI development projects, stay connected with fxis.ai.

At fxis.ai, we believe that such advancements are crucial for the future of AI, as they enable more comprehensive and effective solutions. Our team is continually exploring new methodologies to push the envelope in artificial intelligence, ensuring that our clients benefit from the latest technological innovations.