1. 

   1. Kubernetes first steps

   Learn how to package, deploy and scale applications with Docker and Kubernetes.

   In this course, you will learn how to build, deploy and scale your application in a Kubernetes cluster.

   You will also learn how to declare and schedule resources to the cluster and understand how to expose architect apps that are designed to be horizontally scalable.

2. 

   2. Advanced deployment strategies in Kubernetes

   Learn how to deploy apps into production without any downtime and incrementally.

   Every time you deploy new features in production you don't want to stop your service, load a new version and remove the holding page.

   Ideally, you should be able to transition to a new version of your application without anyone noticing any downtime.

   You can leverage Kubernetes to do that.

   You will learn different techniques to deploy your applications with zero downtime. The module covers the following topics:

   • Is the app down for everyone or just me?
   • Before you start
   • Rolling updates
   • Services and selectors
   • Canary deployments
   • Blue-green deployments
   • Rolling back a deployment
   • Challenges
3. 

   3. Kubernetes architecture

   Learn how to build (and break) a Kubernetes cluster.

   Can Kubernetes recover from failures?

   In this course, you will learn the Kubernetes core components by building a cluster from scratch using kubeadm.

   But the best way to learn something is by breaking it!

   So you will also break the cluster one node at the time and observe what happens.

   The module covers the following topics:

   • Single and multi-node clusters
   • Examining the control plane
   • Persisting changes in etcd
   • Syncing changes with RAFT
   • Event-based architecture
   • Understanding the kubelet
   • Verifying "no single point of failure"
   • Setting up a multi-master cluster
   • Investigating multi-master setup in EKS
   • Exploring multi-master setup in Monzo
   • Creating a 3 node cluster with kubeadm
   • Installing an overlay network
   • Installing an Ingress controller
   • Exploring the API without kubectl
   • Taking down the cluster one node at the time
4. 

   4. Kubernetes networking

   Learn how the traffic is routed inside and outside a Kubernetes cluster.

   How do you route external traffic to your applications in the cluster?

   How can two apps in the cluster talk to each other?

   How is Kubernetes assigning IP addresses to Pods and Services?

   In this course, you will learn the basics as well as some advance topics about networking in Kubernetes.

   The module covers the following topics:

   • Network routing in Linux
   • Understanding network requirements
   • Exploring the Endpoints
   • Balancing in-cluster traffic
   • Routing traffic with kube-proxy
   • CRI, CNI, CSI: interfaces for the kubelet
   • Choosing between latency and load balancing
   • Pros and cons of the 4 types of Services
   • Discovering Services
   • Routing traffic with an Ingress controller
   • End-to-end traffic journey
5. 

   5. Advanced Kubernetes networking

   Learn how to build a CNI from scratch in bash.

   Dive into the specifics of network interfaces, IP addresses and network topologies in this course about advanced Kubernetes networking.

   Learn how to build your Kubernetes network and how the Container Network Interface (CNI) works.

   And while you're at it why not try making your very own Container Network Interface (CNI)?

   You will learn how to build your own Container Network Interface (CNI). The module covers the following topics:

   • Exploring the Node network
   • Cluster networking
   • The Container Network Interface (CNI)
   • Designing a CNI plugin from scratch
   • Implementing a CNI plugin
   • Installing and testing a custom CNI plugin
6. 

   6. Managing state in Kubernetes

   Learn how to manage stateful applications in Kubernetes.

   How does Kubernetes store state?

   Can you host databases in your cluster?

   Can you extract configurations and share them with different deployments?

   How do you make sure that your storage layer is replicated and persisted even if a node becomes unavailable?

   In this course, you will learn how to deploy a database with durable persistence.

   The module covers the following topics:

   • Managing configurations
   • Managing secrets
   • Using Kubernetes Volumes
   • Creating Persistent Volumes
   • Creating Persistent Volume Claims
   • Provisioning volumes dynamically
   • Managing stateful applications
   • Creating volumes on bare metal
   • Deploying a single database with persistence
   • Deploying a clustered database with persistence
   • Designing storage that can span multiple nodes
7. 

   7. Autoscaling in Kubernetes

   Scale your app with standard and custom metrics.

   After deploying your app to production, the received traffic may change in unpredictable ways.

   How do you keep your app responsive at all times?

   You can adapt the number of replicas.

   But is it feasible to do this manually, or are there better ways?

   In this course, you will learn how to autoscale an application based on an application-specific custom metric.

   The module covers the following topics:

   • Introduction to autoscaling
   • The Horizontal Pod Autoscaler
   • The Kubernetes metrics registry
   • Exposing metrics from your apps
   • Installing and configuring Prometheus
   • Understanding custom and external metrics adapters
   • Tuning the Horizontal Pod Autoscaler
8. 

   8. Templating Kubernetes resources

   Learn how to template YAML resources with Helm.

   Resources in Kubernetes are described as YAML files.

   If you wish to have the same resources for different environments such as development, preproduction and production, you may be tempted to copy the files three times.

   Or you could use a templating engine.

   In this course, you will learn how to do precisely that with Helm.

   You will learn how to deploy applications to several environments such as dev, staging, prod without repeating yourself. The module covers the following topics:

   • Creating reusable templates
   • Helm's templating engine
   • Understanding the Helm architecture
   • Templating resources with Go and Sprig
   • Managing releases with Helm
   • Writing helper functions
   • Reverting changes with rollbacks
   • Depending on other charts
   • Storing reusable templates in repositories
9. 

   9. Building your own service mesh

   Learn how to build a service mesh from scratch.

   When you have dozens, hundreds or even thousands of applications interacting in your cluster, it's hard to tell what is going on.

   What if you could inspect the traffic without affecting routine operations?

   What if you could upgrade the network and encrypt communications?

   In this course, you will explore what a Service Mesh is and how you can build your own.

   The module covers the following topics:

   • Why service meshes?
   • Envoy
   • Circuit breaker, rate limiting and filters
   • Envoy discovery service
   • Envoy and Kubernetes integration
   • Load balancing with Envoy
   • Building a basic service mesh
10. 

    10. Authentication

    Learn how authentication works in a Kubernetes cluster.

    How are requests to the Kubernetes API authenticated?

    What types of credentials does Kubernetes support?

    What does it mean that Kubernetes delegates the management of users to an external user management system?

    And how can you integrate Kubernetes with an existing user management system?

    In this course, you will learn everything you need to know about Kubernetes authentication.

    The module covers the following topics:

    • How authentication works
    • Authentication plugins
    • Implementing an authentication service with LDAP
    • Deploying the authentication service
    • Testing the authentication method

Is there any preview of the content?

I already bought all courses →