Posted on

Architecture of Kubernetes

We are going to discuss things related to Kubernetes architecture in this blog.

Prerequisites

  1. Basic Understanding of Cloud.
  2. Basic Understanding of Docker.

Kubernetes

  • Kubernetes is the Container Management Orchestration Tool which Google develops for managing their own microservices across the different clusters.
  • Kubernetes, also called K8s, basically is Numeronym Standard that is used since the 1980s. For Example, In the K8s, there are 8 words in between K and S like that.
  • Google developed an internal system called Borg and later named Omega, which they use to Orchestrate the Data Center.
  • In 2014, Google introduced Kubernetes as an Open Source, and it is written in Golang language. Later on, donated to CNCF.
  • Kubernetes is a tool that automates container deployment, load balancing, and auto-scaling. It will manage all the containers which are running in different environments.

Feature of Kubernetes

  • Orchestration Support: Kubernetes provides a cluster to manage multiple containers which are running in different environments.
  • Auto Scale Application: It will auto-scale the application as per our requirements and network traffic.
  • Automate the Deployment: Using Kubernetes, we automate our deployment process using different cloud provider services.
  • Fault Tolerance: It will manage all the things related to the container; suppose our container is running under different nodes and pods, and Kubernetes found one of the pods, and the container stops working, then it will manage incoming network traffic.
  • Load Balancing: It will balance a load of our application using different nodes and pods which are in running mode.
  • Platform Independent: It will manage all types of applications that are running under a different environment like virtual, cloud, and physical machines.
  • Health Monitoring: It will manage the health of containers that are running under different types of pods.
  • Rollback: We are also able to roll back the application version using Kubernetes.
  • Batch Execution: We are also able to execute some functionality simultaneously and parallelly.

The Architecture of Kubernetes

Architecture of Kubernetes

There are two nodes which is used by Kubernetes while running the application, which will see one by one.

Posted on

Painters Tape and Fault Tolerance

Snipping the top bit of Nicholas C. Zakas’s Top of the Month newsletter (go sign up!), with permission.

One of my favorite things in the world is painters tape (also called masking tape). It seems like something silly: some tape you put on a wall when you’re painting to avoid getting paint on the wall. The tape doesn’t have a strong adhesive, so it can be pulled back off the wall without damaging it. What I love about painters tape is the philosophy behind it: painting is messy, and rather than trying to avoid making a mess, painters tape allows you to make a mess initially and then clean it up easily. Even the best, most talented painter is going to splatter some paint here and there, get distracted, or otherwise end up with paint going where it shouldn’t. It’s a lot faster, easier, and less frustrating to use painters tape to cover up areas where paint is likely to go and then remove the tape to create a nice, clean, finished area. What does this have to do with software engineering?

Painters tape is all about a concept called fault tolerance. Instead of expecting everything to go well, you instead expect that there will be mistakes. When you expect there to be mistakes, you make decisions not to avoid all mistakes but rather to easily recover when a mistake occurs. Got paint where it shouldn’t be? It doesn’t matter if that spot was covered by painters tape. Forgot to put on the painters tape? Now that mistake is a bigger deal. As software engineers, we can think the same way with the code we write.

Making your code fault tolerant is about asking yourself the question: how will this fail? Not if it will fail, but assuming that it will fail, and in which ways will it fail?

The post Painters Tape and Fault Tolerance appeared first on CSS-Tricks.

You can support CSS-Tricks by being an MVP Supporter.

Posted on

Improving the Developer Experience of Writing Cloud-Native Java Microservices

In the third of our new 4-weekly Open Liberty releases, we have a full implementation of MicroProfile 2.2. MicroProfile 2.2 focuses on improving the developer experience of writing cloud-native Java microservices with MicroProfile. It includes updates to the MicroProfile Rest Client, Fault Tolerance, OpenAPI, and Open Tracing features, and is based on Java EE 8 technologies.

If you're using Maven, here are the coordinates: