Skip to content

Home

Jump to bottom
Anthony Hudnall edited this page Mar 14, 2024 · 1 revision

Welcome to the Kubernetes wiki!

KUBERNETES

Kubernetes is an open-source container orchestration platform that automates the deployment, scaling, and management of containerized applications. It was originally developed by Google and is now maintained by the Cloud Native Computing Foundation (CNCF).

Kubernetes provides a flexible and scalable infrastructure for running applications in containers, allowing for efficient resource utilization and easy scaling. It abstracts away the underlying infrastructure and provides a consistent API for managing and interacting with containers.

Some key features of Kubernetes include:

  • Container Orchestration: Kubernetes manages the scheduling and deployment of containers across a cluster of nodes.
  • Automatic Scaling: It can automatically scale applications based on resource usage or defined metrics.
  • Service Discovery and Load Balancing: Kubernetes provides built-in service discovery and load balancing mechanisms.
  • Self-Healing: It monitors the health of containers and automatically restarts or replaces failed containers.
  • Rolling Updates and Rollbacks: Kubernetes supports rolling updates and rollbacks of application deployments, ensuring zero-downtime updates.
  • Secrets and Configuration Management: It allows for secure management of secrets and configuration data used by applications.

Kubernetes has become the de facto standard for container orchestration and is widely adopted in both small-scale startups and large enterprises. It enables developers to focus on building applications without worrying about the underlying infrastructure, while providing operations teams with a powerful tool for managing containerized workloads.

To install Kubernetes on different operating systems:

Windows:

  1. Install Docker Desktop for Windows.
  2. Enable Kubernetes in the Docker Desktop settings.
  3. Docker Desktop will automatically download and set up Kubernetes.

macOS:

  1. Install Docker Desktop for macOS.
  2. Enable Kubernetes in the Docker Desktop settings.
  3. Docker Desktop will automatically download and set up Kubernetes.

Linux:

  1. Use a package manager to install Kubernetes. For example, on Ubuntu, run the following commands:

    sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl
curl -fsSL <https://packages.cloud.google.com/apt/doc/apt-key.gpg> | sudo apt-key add -
echo "deb <https://apt.kubernetes.io/> kubernetes-xenial main" | sudo tee -a /etc/apt/sources.list.d/kubernetes.list
sudo apt-get update
sudo apt-get install -y kubectl

  2. Install a container runtime, such as Docker, if not already installed.

  3. Start the Kubernetes services:

    sudo systemctl enable kubelet.service
sudo systemctl start kubelet.service

These are general installation steps, and you may need to refer to the specific documentation for your operating system and distribution for more detailed instructions.

Here are some common Kubernetes commands:

  • To create a deployment:
kubectl create deployment <deployment-name> --image=<image-name>
  • To list all pods:
kubectl get pods
  • To scale a deployment:
kubectl scale deployment <deployment-name> --replicas=<number-of-replicas>
  • To expose a deployment as a service:
kubectl expose deployment <deployment-name> --port=<port-number> --target-port=<target-port>
  • To check the logs of a pod:
kubectl logs <pod-name>
  • To delete a deployment:
kubectl delete deployment <deployment-name>

These are just a few examples of the many commands available in Kubernetes. They can be used to manage and interact with your containerized applications.

Kustomize

Kustomize is a built-in tool in Kubernetes that allows for customization of Kubernetes YAML manifests without directly modifying the original files. It provides a simple and declarative way to manage configuration overlays for Kubernetes resources.

With Kustomize, you can create overlays that modify existing Kubernetes resources, such as deployments, services, or config maps, without changing the base manifests. This enables you to maintain a separation between the base configuration and the customization, making it easier to manage and apply changes across different environments or scenarios.

Some key features of Kustomize include:

  • Resource Patching: Kustomize allows you to selectively patch or modify specific fields within a resource without modifying the entire file. This is especially useful for applying environment-specific configurations or making targeted changes to existing resources.
  • Configuration Overlays: Kustomize uses overlays to apply different configurations to the base resources. Overlays can be used to add, update, or remove resources, as well as modify fields within the resources. This makes it easy to create different variations of your application configuration for different environments or deployment scenarios.
  • Parameterization: Kustomize supports parameterization, allowing you to define variables and use them within your configuration overlays. This makes it convenient to customize configurations based on specific requirements or to reuse common configurations across different environments.
  • Composition: Kustomize supports composition, which allows you to reuse and combine multiple customization layers. This enables you to create modular and reusable configurations that can be shared across different projects or teams.

To use Kustomize, you typically create a kustomization.yaml file that defines the customization rules and overlays. This file specifies the base resources, patches, and other customization options. You can then use the kubectl apply -k command to apply the Kustomize configuration to your Kubernetes cluster.

Kustomize is a powerful tool that simplifies the management of Kubernetes configurations and helps streamline the deployment process. It provides a flexible and scalable approach to managing configuration overlays and reduces the need for manual modifications to base configuration files.

Here are some common Kustomize commands:

  • To apply a Kustomize configuration:
kubectl apply -k <path-to-kustomization-directory>
  • To preview the resources that will be created or modified by the Kustomize configuration:
kubectl kustomize <path-to-kustomization-directory>
  • To generate the final YAML manifests without applying them to the cluster:
kubectl kustomize <path-to-kustomization-directory> > output.yaml
  • To combine multiple Kustomize configurations:
kubectl kustomize <path-to-kustomization-directory-1> <path-to-kustomization-directory-2> > output.yaml

These commands can be used to apply, preview, or generate the final YAML manifests based on your Kustomize configurations.

Remember to replace <path-to-kustomization-directory> with the actual path to your Kustomize configuration directory.

Clone this wiki locally