Develop and Operate Microservices on Kubernetes

Practical implementation of concepts already shown in 1.4; create resilient and scalable deployments using ReplicaSets.

• Learn about Labeling
• Define and create a ReplicaSet
• Scale a ReplicaSet 

Kubernetes Pods do not provide a stable network identity that other applications could connect to. Service objects offer a solution to that problem.

• Learn what problems services solve
• Define and test a service
• Learn about LoadBalancer services 

Kubernetes service only provides simple TCP/UDP forwarding. Ingress controllers offer more sophisticated HTTP request routing features.

• Learn about service shortcomings and how Ingresses solve them
• Learn about different ingress controllers
• Define and test an Ingress definition 

ReplicaSets provide scalable and resilient application deployments; but they do not provide a robust mechanism for providing updates. This problem is solved by Deployment objects.

• Learn about how ReplicaSets do not provide application updates and how Deployments do
• Define and test a Deployment with rolling update
• Learn how to roll back a failed deployment to a previous version 

Up until now, we have only learned how to deploy stateless applications; this section introduces the concept of stateful applications and illuminates under which circumstances you should decide for which kind of storage engine.

• Learn about Stateful applications
• Learn about Persistent Volumes
• Learn about Network Block Devices and Network File Systems 

Managing network volumes is a complex tasks; Kubernetes breaks this down into separately managing PersistentVolumes and PersistentVolumeClaims.

• Learn about separation of concerns in working with storage volumes
• Define a PersistentVolume and claim it
• Define a Pod that uses the PersistentVolume created before 

Manually creating PersistentVolumes is time-consuming and tedious. Automatic Volume Provisioning and Storage Classes offer a solution for this.

• Learn about Storage Classes and automatic provisioning
• Define a Storage Class
• Define a PersistentVolumeClaim using a Storage Class 

Sometimes you will need to deploy clustered applications in which each instance will require its own private persistent volume. This is often the case when deploying databases. This can be done using StatefulSets.

• Learn about StatefulSets and Headless Services
• Define and create a StatefulSet
• Learn about the exact differences between StatefulSets and ReplicaSets 

Often, your application will require various configuration values. While you could just define these as Pod environment variables, ConfigMaps offer a solution that is easier to manage.

• Learn about different kinds of configuration data
• Define a ConfigMap
• Use a ConfigMap to initialize environment variables in a Pod 

Using ConfigMaps to manage environment variables is a useful feature – but often, applications require entire configuration files to run. This can also be solved using ConfigMaps.

• Learn how to store large files in a ConfigMap
• Use a ConfigMap as a volume in a Pod
• Learn how to create a ConfigMap from an existing directory containing configuration files 

ConfigMaps are great, but not secure. Secrets work similar to ConfigMaps, but are designed to store secret data like password, API keys and other sensitive data.

• Learn about the difference (and similarities) between ConfigMaps and Secrets
• Learn how to create a Secret and to use it in a Pod
• Create a secret from existing files or direct user input 

Typically, you will want to deploy your application automatically from a source code repository as soon as changes are made in the repository. This video will show you how a typical Continuous Delivery pipeline in Kubernetes looks like.

• Learn what Continuous Integration and Delivery is (in a nutshell)
• Discuss different possible typical build pipelines
• Learn about typical caveats and how to solve them 

GitLab is a popular solution for both version control and Continuous Integration and Delivery. This video will show how to implement the deployment pipeline shown earlier using GitLab CI.

• Learn about GitLab
• Define a deployment pipeline using GitLab CI
• See a deployment pipeline in action 

Often, Kubernetes deployments are complex and consist of multiple objects that are difficult to manage manually. This can be made easier using the Helm package manager.

• Learn about Helm and its basic architecture
• Define a Helm chart for your application
• Deploy that Helm chart into your cluster 

This video combines the knowledge from the previous two and shows how to build a continuous delivery pipeline using GitLab CI and Helm.

• Use Helm in a GitLab CI pipeline
• Release and deploy a new version of your application
• Lean back and let GitLab do the rest