Learn Kubernetes Docker/DevOps and helm charts from scratch

Students will learn how to set up a completely new instance (a server or a virtual machine) at scaleway.com. There are plenty providers available to purchase a server temporary. If not wanting to pay for instances, one could install VMWare (VirtualBox) and setup a virtual machine over there.

Students will learn how easy it is disable SELINUX at their machines.

When lunching CentOS 7.x operating system at Scaleway, all ports are open that's why students will learn how to setup firewall. Students will understand how to install firewalld service if not installed already. It is a good practice to secure available ports with firewall rules to prevent unexpected attacks. Most of the infrastructure tend to disable firewall completely and secure their infrastructure by additional firewall layer at network components.

Students will learn how to allow bridge interface at CentOS 7.x. At the same time they will understand how to make a router out of their linux servers by allowing some kernel parameters.

Students will learn how to install docker at CentoOS 7.x.

Students will learn how to install the key OS level packages (kubeadm, kubectl and kubelet) necessary to start Kubernetes cluster at CentOS 7.x OS.

Students will learn how to start up Single node Kubernetes cluster at one server. This Kubernetes node acts as Kubernetes Master. It is possible to allow pod scheduling (effectively an application deployment) at this Kubernetes which is disabled by default.

Weave is a network overlay used by Kubernetes for internal communication between particular components running in Kubernetes. Students will learn how to deploy it to their cluster and how to pass some custom configuration.

Students will learn how to setup helm binary at their local machine. Helm is used to deploy apps to Kubernetes. Helm is using so called "helm charts" as deployment descriptors that Kubernetes understands.

Student will learn how to exchange SSL keys between helm (client) and tiller (server) deployed in Kubernetes cluster.

Students will learn how to provision a server at scaleway.com which will be acting as Kubernetes Worker. This would be pretty much the same as the provisioning of the Kubernetes Master server.

Students will learn what configuration changes are necessary to do when configuring Kubernetes Worker/Node.

• disable selinux

• turn off swap

• setup bridge interface

• install: docker, kubelet, kubeadm, kubectl

  
  

Students will learn how which ports have to be allowed by firewalld if a Worker Kubernetes node is being added to Kubernetes cluster.

This lecture will guide students through the process of joining Kubernetes Worker to a Single node Kubernetes cluster.

• <kubeadm join command> has to be generated at Kubernetes Master node

• copy <kubeadm join command> from Kubernetes Master and execute it at the server which is being added to an existing cluster (made of one node - Kubernetes Master)

Here is my full free youtube tutorial https://www.youtube.com/channel/UC9MlJYbRIIIGTR-5Raf_Euw/
on how to use this terraform code to provision the Kubernetes cluster by using kubeadm automatically (instances included).

Related Github project: https://github.com/xjantoth/scw-microservice-tf

Here is my full free youtube tutorial https://www.youtube.com/channel/UC9MlJYbRIIIGTR-5Raf_Euw/
on how to use this terraform code to provision the Kubernetes cluster by using kubeadm automatically (instances included).

Related Github project: https://github.com/xjantoth/scw-microservice-tf

Student will get an idea which applications will be deployed to a Kubernetes cluster. The final architecture will be made of:

1) database (PostgreSQL)
2) back-end Python Flask app
3) front-end React app

all resources are being in https://github.com/xjantoth/microservice

Student will learn about back-end Python Flask application which will be deployed to a Kubernetes cluster.

1) database (PostgreSQL)
2) back-end Python Flask app

all resources are being in https://github.com/xjantoth/microservice

Student will learn how to run back-end Python Flask app locally at your laptop by using flask run command.

1) database (PostgreSQL)
2) back-end Python Flask app

all resources are being in https://github.com/xjantoth/microservice

Student will learn how to run back-end Python Flask app locally as docker container command
docker run --name <container-name> -it ... -p 5001:8000 -d <account>/microservice:v0.0.1.

1) database (PostgreSQL)
2) back-end Python Flask app

all resources are being in https://github.com/xjantoth/microservice

Students will learn a little bit more about how the mechanism of application running inside
the docker container is responding to the requests executed from command line.

Students will understand the difference between:

from the host (laptop)
# flask instance run locally by export FLASK_APP=app && flask run
curl http://127.0.0.1:5000/{isalive,getallips,saveip} 
# flask instance run as docker container docker run ... -d <account>/microservice:v0.0.1
curl http://127.0.0.1:5001/{isalive,getallips,saveip}

from inside of the docker image
docker exec -it <container-name> sh
curl http://127.0.0.1:8000/{isalive,getallips,saveip}

Students will learn how to push a locally build docker image to a public docker registry.

Students will learn how to push a docker image to a public docker registry for remote storage.

Students will understand how front-end React app is designed and how to run it locally for debugging.

all resources are being stored in https://github.com/xjantoth/microservice

Students will learn how to build a docker image for React app (2 stage docker  build process)
locally based on Dockerfile.

all resources are being stored in https://github.com/xjantoth/microservice

Students will learn how to run docker image as a docker container. They will in fact learn a little bit about to to exec to a running docker container. This will help them better understand how everything works when running containers.

all resources are being stored in https://github.com/xjantoth/microservice

Students will learn how to push a locally build docker image to a public docker registry.

Students will be introduced with concepts of helm chart and their deployment to Kubernetes cluster.
For the sake of this example students will be present with Dokuwiki deployment.

Students will practically learn how to grab a publically available helm chart and deploy it to Kubernetes cluster
within few seconds with "one-liner".

Students will learn how to create a helm chart locally when executing helm create <some-name>. They will be guided through a helm chart structure.

Students will learn how to modify values within values.yaml file for micro-backend helm chart (helm charts in general). They will be also present with the concept of dependencies withing helm charts. When it comes to micro-backend helm chart - this one is dependent on postgresql database - that's why the postgresql helm chart will be a natural dependency for this micro-backend helm chart.

Students will learn how to deploy micro-backend helm chart against the Kubernetes cluster by using helm command. They will also learn how to use --set option to modify some values from values.yaml file on the fly.

Here is my full free youtube tutorial https://www.youtube.com/channel/UC9MlJYbRIIIGTR-5Raf_Euw/
on how to use this terraform code to provision the Kubernetes cluster by using kubeadm automatically (instances included).

Related Github project: https://github.com/xjantoth/scw-microservice-tf

This lecture guides you how to deploy micro-backend Python Flask application by using Helm v3 binary.

Students will learn how to access Python instance running in Kubernetes POD via service of type of NodePort. When NodePort type of service set - the nodePort is automatically exposed at every physical node (server) which belongs to this Kubernetes cluster.

Students will learn how to start one more pod in their Kubernetes clusters. This pod will get a member of "Kubernetes world" - mainly weave overlay network - so they can communicate at the same network subnet. Python instance can be then called via the corresponding Service at port 80.

Students will learn how to "get inside the POD" when using command:
kubectl exec -it <pod-name> -- sh.

It's beneficial to understand the inner POD (docker) filesystem can be explored. Student then

can call the python instance directly from inside of POD at port 8000.

Students will learn how to create "bare" helm chart (By "bare" helm chart I mean the one which is created by helm create <some-helm-chart-name>). Afterwards, students will learn how to fill in all the details in values.yaml file, mainly how to use previously build docker image and put use it it their helm charts.

Students will learn how to deploy micro-frontend helm chart by using:

helm install --name frontend --set service.type=NodePort --set service.nodePort=30333 helm-charts/micro-frontend --tls command.

Here is my full free youtube tutorial https://www.youtube.com/channel/UC9MlJYbRIIIGTR-5Raf_Euw/

on how to use this terraform code to provision the Kubernetes cluster by using kubeadm automatically (instances included).

Related Github project: https://github.com/xjantoth/scw-microservice-tf

This lecture guides you how to deploy micro-frontend React application by using Helm v3 binary.

This lecture covers nginx-ingress helm chart controller. Nginx-ingress controller takes advantage of all available ingress objects present in Kubenretes cluster (ingress objects configurations) and reflects them in its own configuration. Such a setup allows routing traffic to particular services:

http://k8s.domain.name:<nodePort>/app/    (micro-frontend helm chart service)

http://k8s.domain.name:<nodePort>/api/ *  (micro-backend helm chart service)

Here is my full free youtube tutorial https://www.youtube.com/channel/UC9MlJYbRIIIGTR-5Raf_Euw/

on how to use this terraform code to provision the Kubernetes cluster by using kubeadm automatically (instances included).

Related Github project: https://github.com/xjantoth/scw-microservice-tf

This lecture guides you how to deploy Nginx Ingress Controller application by using Helm v3 binary.

Here is my full free youtube tutorial https://www.youtube.com/channel/UC9MlJYbRIIIGTR-5Raf_Euw/

on how to use this terraform code to provision the Kubernetes cluster by using kubeadm automatically (instances included).

Related Github project: https://github.com/xjantoth/scw-microservice-tf

This lecture guides you how to remove NodePorts from micro-backend and micro-frontend deployments by using Helm v3 binary.

Students will learn how to check the configuration of nginx-ingress controller (nginx.conf file inside pod) to verify that specifications for:

• micro-backend helm chart ingress kubernetes object

• micro-frontend helm chart ingress kubernetes object

are indeed reflected in nginx.conf file.

Students will learn how to scale their deployment for micro-backend helm - changing the number of desired pods equal to 3.

Students will learn how to use helm upgrade ... command.

Students will learn how to scale up the front-end deployment for micro-frontend helm chart.

helm upgrade frontend --set replicaCount=2 --set service.nodePort= helm-charts/micro-frontend  --tls