Google Kubernetes Engine
1. Google Kubernetes Engine
MIKE DUNKER: Next is Google Kubernetes Engine. Kubernetes is a leading open source platform for deploying, scaling, and operating containers. Kubernetes, first developed at Google, is now a Cloud Native Computing Foundation project with a large and active community. Kubernetes provides you with a framework to run distributed containerized systems resiliently and at scale. It manages many operational tasks, such as scaling application components, providing network abstractions, orchestrating failovers, rolling out deployments, storage orchestration, and management of secrets and configurations. A Kubernetes cluster contains control plane and worker nodes. The nodes in a cluster are the machines-- virtual or physical-- that run your applications. The Kubernetes Control Plane manages the worker nodes and the pods in the cluster. A pod is a group of containers that share networking and storage resources on the node. Google Kubernetes Engine, or GKE, is a managed Kubernetes service on Google infrastructure. GKE helps you deploy, manage, and scale Kubernetes environments for your containerized applications on Google Cloud. More specifically, GKE is a component of the Google Cloud compute offerings that facilitates bringing your Kubernetes workloads into the cloud. For an unmanaged cluster, you need to manage most of the operational aspects of the cluster yourself. GKE handles much of this operational effort for you automatically by eliminating many of the infrastructure tasks required to create and manage a Kubernetes cluster. With GKE, Google manages most of your cluster tasks. Google manages the control plane, scaling of pods, node patching and upgrades, and the monitoring, availability, and reliability of the cluster. By default, you manage the underlying nodes and node pools, including provisioning, maintenance, and lifecycle management. You're also responsible for selecting the security and networking configuration for your cluster. This level of management is the standard mode for GKE. GKE Autopilot is a mode of operation in which the entire cluster's infrastructure is managed for you, including control plane, node pools, and nodes. By managing the cluster infrastructure, Autopilot helps reduce operational and maintenance costs while improving resource utilization. Autopilot is a fully-managed Kubernetes experience that lets you focus on your workloads instead of the management of the cluster's infrastructure. Autopilot automatically implements GKE hardening guidelines and security and networking best practices and blocks less safe practices. GKE Standard mode provides customers with advanced configuration flexibility over the cluster infrastructure. GKE Autopilot mode lets Google provision and manage the entire cluster and underlying infrastructure. You can use different modes for different clusters, depending on how much infrastructure control you need. GKE is fully managed, which means that you don't have to provision the underlying resources. GKE uses a container-optimized operating system to run your workloads. Google maintains this operating system, which is optimized to scale quickly with a minimal resource footprint. When you use GKE, you start by directing the service to instantiate a Kubernetes cluster for you. The GKE AutoUpgrade feature, when enabled, ensures that your clusters are always automatically upgraded with the latest stable version of Kubernetes. The virtual machines that host your containers in a GKE cluster are called nodes. Auto-repair can automatically repair unhealthy nodes for you. It performs periodic health checks on each node of the cluster. If a node is determined to be unhealthy and requires repair, GKE will drain the node, thus allowing workloads to gracefully exit. It will then recreate the node. GKE and Kubernetes both support the scaling of workloads within a cluster. GKE also supports scaling of the cluster itself. GKE uses Cloud Monitoring and Cloud Logging to help you monitor and understand your application's performance and behavior. GKE seamlessly integrates with many parts of Google Cloud. With Cloud Build, you can use private container images that you've securely stored in Artifact Registry to automate the deployment of your workloads. Identity and access management lets you control access by using accounts and role permissions. GKE is integrated with Virtual Private Clouds, or VPCs, which lets you use Google Cloud's networking features. And finally, the Google Cloud Console provides insights into GKE clusters and their resources, thus letting you view, inspect, and delete resources in those clusters. GKE supports any application runtime that you can package as a Docker image. GKE is ideally suited for containerized applications, including third-party containerized software. You can run your container image on Kubernetes in a hybrid or multi-cloud environment. This feature is especially helpful when some parts of your application run on premises and other parts run in the cloud. You can use GKE to run containerized applications that use network protocols other than HTTP and HTTPS. Managing the infrastructure for a Kubernetes environment can be complex. GKE simplifies many of the operational tasks associated with provisioning and managing the infrastructure. With GKE, Google Cloud persistent disks are automatically provisioned by default when you create Kubernetes persistent volumes to provide storage for stateful applications. GKE automatically provisions Google Cloud network load balancers when You deploy Kubernetes network load balancer services and provisions Google Cloud HTTP and HTTPS load balancing when you configure Kubernetes Ingress resources. This auto-provisioning feature eliminates the need to configure and manage these resources manually. GKE has support for Google Cloud Observability, which provides integration with tools for troubleshooting and application and service monitoring. With GKE, you can implement a robust, production-ready AI/ML platform with all the benefits of managed Kubernetes. GKE provides infrastructure orchestration that supports GPUs and TPUs for training and service of AI/ML workloads at scale. With GKE Standard mode, you create node pools of VMs with attached GPUs or TPUs and then allocate GPU or TPU resources to containerized workloads running on those nodes. With GKE Autopilot mode, you specify the GPU or TPU resources you need for your workloads, and GKE can automatically manage nodes that provide those resources. GKE simplifies cluster deployment and scaling. You can describe the compute, memory, network, and storage resources that you want to make available across all the containers required by your applications. GKE will provision and manage the underlying Google Cloud resources automatically. You can either deploy fixed-size clusters or configure your clusters to automatically scale. Auto-scaling adds or removes compute instances in response to changes in the resource requirements of the containers that run inside the cluster. You deploy and manage your containerized application for GKE the same way you would for any other Kubernetes environment. You can use the kubectl command to perform most operational tasks. Although you can deploy ad-hoc resources directly by using kubectl commands, the recommended best practice is to use YAML manifest files to define configurations. These files define the properties of the containers that are used for the components in your applications. Manifest files can also define the network services, security policies, and other Kubernetes objects that are used to deliver resilient, scalable, containerized applications. Applications can be deployed by using deployments, where Kubernetes continually ensures that a specified number of replicas for a pod or set of pods is running. The deployment shown here is for stateless components. You can also use stateful sets for applications where you need persistent storage. You can also use YAML manifest to define a range of other resource types. As a part of a continuous integration and delivery CI/CD pipeline, you can generate a new Docker image for each code commit. The CI/CD pipeline can automatically deploy the image to development, test, and production environments. Cloud Build, Artifact Registry, Cloud Deploy, and GKE can be used to create a strong CI/CD system.2. Let's practice!
Create Your Free Account
or
By continuing, you accept our Terms of Use, our Privacy Policy and that your data is stored in the USA.