Discover how to build, deploy, scale, and manage Kubernetes. Gain insights into architecture, pods, deployments, services, and run real-world projects to solidify your skills.

kubernetes.tar.gz

kubernetes

port-30001

port-3000

port-4567

port-8001

Port-3001

Port-3001-v1

Kubernetes in Practice is your one-stop shop for learning how to build, deploy, scale, and manage Kubernetes in a step-by-step process.

You will learn all the most important concepts including: architecture, pods, deployments, services, ingress, and a whole lot more. Once you have the fundamentals out of the way, you will get the opportunity to put your skills to work in a project where you will create and run an application in a real Kubernetes cluster.

By the time you finish this course, you will have complete confidence when it comes to deploying and managing kubernetes clusters.

Kubernetes in Practice

# Deployment Manifest

Just like we defined a manifest for our `nginx` pod, we need to define a manifest for a deployment, and they actually look fairly similar:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hellok8s
spec:
  replicas: 1
  selector:
    matchLabels:
      app: hellok8s
  template:
    metadata:
      labels:
        app: hellok8s
    spec:
      containers:
      - image: brianstorti/hellok8s:v1
        name: hellok8s-container

Let's go through all the fields in this manifest to understand what's happening.  First, we tell Kubernetes what kind of object we are defining here. In our case, this is a Deployment.

In the `metadata.name` field, we define a unique name for our deployment. This can be anything that helps you identify what this deployment is managing.

In the `spec` section, we define what this deployment will do. First, we define how many `replicas` we want. That is, how many exact copies of this pod we want to run. For now, we’re running just one replica, but we will play with that field in a bit.

The `selector` section is probably the only thing that's not super intuitive right away. What we are doing in this field is telling Kubernetes that this deployment is managing all the pods that have a label called `app` with the value `hellok8s`. This is what links deployments to pods.  Labels are simply key-value pairs that you define for your pods, and that's what is used to find all the pods that a Deployment needs to look after.

Then we define the `template` section: that's the definition of pods that we want to run. Here, we are defining a pod with the label `app: hellok8s` (to create the link with the deployment) and saying this pod will run the `brianstorti/hellok8s:v1` docker image.

This can be a bit daunting the first time you see it, but as you start using and writing more manifests, it will become natural.

Learn how to define our own manifest for deployment.

Before We Begin

What Kubernetes Brings to the Table

Kubernetes Architecture

Pods

Deployments

Services

Deploying a Web Application over Kubernetes

Ingress

Configuring Applications with Configmaps

Using Secrets for Sensitive Configs

Running Jobs

Fault-Tolerant Web Hosting on Kubernetes

Organizing Resources with Namespaces

Managing Containers Resource Usage

Understanding the Kubeconfig File

Kubernetes IRL

Appendix

Wrap Up!

Defining Our Deployment Manifest

Deployment Manifest