Skip to content

Latest commit

 

History

History
112 lines (75 loc) · 4.64 KB

README.md

File metadata and controls

112 lines (75 loc) · 4.64 KB

DevOps Pizza App

The following Django based application consists of two main parts:

  1. Order Placement Form: A form that allows users to place orders for pizza. This form should include: a. A dropdown menu for selecting the type of pizza (e.g., Margherita, Pepperoni, Vegetarian, etc.). b. A text area for comments or special instructions.
  2. Orders Table: A page that displays all placed orders in a tabular format. Each row should display the type of pizza ordered and any comments associated with the order.

Required CLI tools:

  • Docker [1]
  • Minikube [2]
  • Kubectl [3]

Running Container Locally

To run this container app locally the following commands:

docker build -t django-pizza-app .
docker run -p 8000:8000 django-pizza-app

Running on Minikube

For this initial setup, Minikube [2] was selected to run this application locally. Any other Kubernetes provider can be used (EKS, GKE, ...) if decided to move to a Production workload.

  1. Install the Minikube CLI tool, for MacOS run:
brew install minikube
  1. Start and activate Minikube env, this will also point your local kubectl profile to the Minikube cluster:
minikube start
eval $(minikube docker-env)

  1. Deploy Docker image with either one of the following two options, if any local testing is needed, the Minikube registry can be used before making any updates on the currently DockerHub [4] hosted image.

    1. Deploy image locally to Minikube registry

      1. Enable Minikube Registry add-on:
      minikube addons enable registry
      1. Build Docker image:
      docker build -t django-pizza-app .
      1. Tag and push the image to Minikube:
      docker tag django-pizza-app:latest localhost:5000/django-pizza-app:latest
docker push localhost:5000/django-pizza-app:latest
      1. Set k8s/deployment.yaml image value to: localhost:5000/django-pizza-app:latest

    2. Use DockerHub image [5]

      1. Make an update on one of the following directories: pizza_app or orders, or on the Dockefile, make a PR and once merged it will trigger a CI pipeline that will build and push the image to alejandroariaszuluaga/django-pizza-app DockerHub.

      2. Set k8s/deployment.yaml image value to: alejandroariaszuluaga/django-pizza-app:latest

  2. Apply Kubernetes manifests:

kubectl apply -f k8s/deployment.yaml
kubectl apply -f k8s/service.yaml
  1. Port-forward the app to localhost:
kubectl port-forward svc/django-pizza-app-service 8000:8000
  1. Access the app through your local browser at http://localhost:8000/

Kubernetes Objects

There are two main Kubernetes objects here:

  1. Deployment: determines how the application will be deployed by defining physical Memory+CPU resource requests/limits, as well as how many containers (pods) will be deployed by defining a replica count.

  2. Service: exposes the application pods through the same service IP, and allows networking being simplified by making it possible to route requests to the service without having to access the IP address of the pod resource.

CI Jobs

Two workflows were developed for this application that can be found at .github/workflows:

  1. Lint: lint.yaml runs two flake8 recommended initial checks that can be tweaked according to the user's requirements. Triggered whenever a new Pull Request is open and checks all Python syntax.
  2. CI for Docker image: ci.yaml runs a Docker build and push against the corresponding DockerHub repository. It uses two secrets stored at this repository's configs: DOCKER_HUB_USERNAME and DOCKER_HUB_ACCESS_TOKEN to get Read/Write access to the DockerHub. Triggered whenever there are changes in any of the Python files or on the Dockerfile

Possible Improvements

Implement CD components such as an ArgoCD configuration where ArgoCD monitors and handles the GitOps side of this application: k8s/ directory and its files. Also, this current app was deployed to Minikube, which is a very useful tool when testing and learning about Kubernetes, but it is always recommended to deploy an app to a Cloud-based Kubernetes cluster provider such as EKS. For infrastructure such as that, any form of Infrastructure as Code will be required (Terraform, CloudFormation, CDK...), which will also require a new pipeline definition to handle that side of Cloud infrastructure GitOps.

References

  1. https://www.docker.com/products/cli/
  2. https://minikube.sigs.k8s.io/docs/
  3. https://kubernetes.io/docs/tasks/tools/
  4. https://hub.docker.com/
  5. https://hub.docker.com/repository/docker/alejandroariaszuluaga/django-pizza-app/general