Clusters in GKE
Anatomy of a Kubernetes cluster
- The most simple way to think of Kubernetes is just like any other cluster.
- It's a collection of computers joined together to perform some function.
- A typical Kubernetes cluster will contain one or more masters and one or more nodes.
- Nodes are just communal gang variety computers.
- These can be large physical servers or even raspberry pies.
In the case of Google Kubernetes engine, they are virtual machines running in Google compute engine.
Kubernetes Master:
- Masters run several components that form what's called the control plane.
- This means they're in charge of controlling the cluster.
- They make decisions about the cluster.
- Such as where to schedule certain workloads.
- The master is responsible for the state of a cluster.
- It's constantly watching everything to make sure the state is as it should be.
Components of a Kubernetes Master.
- API Server:
- The API Server is the front end of the control plane it exposes the API for all the master functions.
- Every time you communicate with the master or anything else communicates with the master It would be through this API.
- Most of the time you'll use google cloud counsel or command line tool but in the background it's always talking to this API.
- Once a cluster is up and running your day to day interaction is just going to be with that API Server.
- And with GKE there is a good reason you don't need to worry too much about this individual components.
- etcd
- etcd is Kubernetes own database.
- Storing all of it's configuration in state.
- We call it a database but really etcd is just a key value store.
- It is very well known one that is designed for scale and higher availability.
- Scheduler
- The Scheduler is responsible for scheduling work loads.
- That means is when you want to deploy a container the scheduler will pick a node to run that container on.
- The node it picks can be affected by all kinds of factors such as the current load on each available node.
- The requirements of your container and some other customizable constraints.
- Cloud Controller Manager
- The Cloud Controller Manager, is what allows Kubernetes to work with cloud platforms.
- Kubernetes itself is an open source project with contributions from lots of large companies
- not just Google So it doesn't natively contain functionality for google cloud only.
- This manager is responsible for handling things like networking and load balancing as they translate to the product and services of a particular cloud platform.
- Kube Controller Manager
- Its job is to manage a handful of controllers in the cluster.
- The controllers themselves look after things like nodes and a few other objects.
Kubernetes Node
- Nodes run components that form the runtime environment.
- There basically the workers with a container runtime.
- In this node computers, provide the resources of the cluster.
- All of the CPU and RAM can be used to run containers
- When you deploy a container in Kubernetes the master will pick a node to run it on.
- These are going to be our actual virtual machines that will run containers for us.
- They're a lot more straightforward than the master.
Component's of Kubernetes node
- Kubelet:
- It is an agent for Kubernetes.
- It communicates with the control play and takes instructions such as deploying containers when it's told to.
- Kube-proxy:
- It is responsible for managing network connections in and out of the node.
- Actual Container Runtime:
- Just like when we run our first container in cloud shell the noble run docker as a container runtime to allow it to run containers.
How to build a Kubernetes cluster?
- The hard way.
- You'll need provision of virtual machines for you master and your nodes.
- You'll need to install the Kubernetes software create a network overlay.
- Set up certificates so that all of the components can talk to each other secularly.
- The easy way.
- Use GKE.
- GKE provisions and manages the underlying cloud resources automatically.
GKE is a fully managed service
- It will create masters and nodes for you to your specification using a container-optimized operating system.
- You design your cluster within GKE without having to build or maintain individual masters or nodes.
- It comes with built-in automatic upgrading, automatic self-repair.
- It has many options for fine grain resource control and cluster scaling.
- Its integrated with all of the other products and services Google cloud platform.
- You don't even touch the master control plane.
- It is completely managed for you.
- It's made of compute engine VMs just like your nodes, but they won't even show up in your project.
- Google's own CRET are looking after them for you.
- Abstracting away the control plane takes away a lot of the operation overhead.
How do we operate and interact with GKE
- Google Cloud Console.
- Kubernetes functionality is exposed to us to the simple UI of the cloud console.
- Command lines for Kubernetis
- Kubectl for operating a running cluster
- Kubectl allows us to interact with Kubernetes by defining the objects we want to deploy.
- These objects are just abstractions of what we want to run and how we want to run it.
- Kubectl takes our instructions and passes them to the API server.
- Communicate with API Server
- Perform their own function to carry out our commands.
- Create and manage life-cycle of Kubernetes objects
- Everything in Kubernetes is an object and every object has a state.
No comments:
Post a Comment