Recommended
More Related Content
What's hot
What's hot (20)
Similar to Kubernetes on GCP
Similar to Kubernetes on GCP (20)
Recently uploaded
Recently uploaded (20)
Kubernetes on GCP
- 1. Fotios Tragopoulos Senior Consultant @ Deloitte Kubernetes on GCP
- 2. 2 About Me o Cloud Enthusiast since 2017 o iOS and OS X Developer since 2014 o Full Stack Developer since 2010 o Industrial Programmer since 2005 Tragopoulos Fotios Cloud Engineer / Consultant ftragopoulos@deloitte.gr Contributions o DuckDuckGo o Odoo ERPTragopoulos Tragopoulos
- 3. Agenda 7 Delving into Kubernetes Google Cloud Containers & Kubernetes1 2 3 4 Cloud Run Kubernetes Engine App Engine6 5 Cloud Functions
- 5. “Containers provide a standard way to package your application's code, configurations, and dependencies into a single object”.
- 6. Container History and Google’s contribution 2000 2004 2006 2008 2013 chroot OpenVZ Linux VServer Warden Control Groups FreeBSD Jails Solaris Containers LXC or LinuX Containers Process Containers by Google 1979 2001 2005 2007 2011 LMCTFY & Docker
- 7. "platform for automating deployment, scaling, and operations of application containers across clusters of hosts" What is Kubernetes?
- 8. Kubernetes History 2013 2015 2017 Borg System K8s Goes Mainstream Kubernetes Omega Kubernetes v1.0 & CNCF Github runs On K8s 2003 2014 2016
- 9. Google Cloud
- 10. For the past 16 years, Google has been building the world’s fastest, most powerful Cloud Infrastructure on the planet.
- 11. For the past 16years, Google hasbeen building the world’s fastest, most powerful CloudInfrastructure on theplanet. Google Cloud Ecosystem
- 17. Cloud Run
- 18. What is Serverless Computing?
- 19. Compute Services
- 20. 20 Cloud Run “Bringing Serverless to Containers”
- 22. 22 Operate Seamlessly with High Availability Scale Effortlessly to Meet Demand Deploy a wide variety of Applications Kubernetes Engine Run Securely on Google's Network $
- 24. App Engine
- 25. Focus on your code Popular languages & frameworks Multiple storage options Deploy at Google scale Powerful built-in services Familiar development tools App Engine
- 26. GKE vs App Engine
- 27. Cloud Functions
- 28. Cloud Functions
- 29. Focus on your Code Event-driven Processing Scales automatically Short-running Code Cloud Functions
- 31. Thank you!
Editor's Notes
- Hi! My name is Fotios Tragopoulos, I’m a cloud enthusiast working with Cloud Technologies for the last three years. I come from a Full Stack background and have worked with several technologies and platforms. I’m in the industry since 2005 and have worked as an industrial programmer, iOS and OS X developer and currently as a Cloud Engineer. I participated in several Open Source communities and contributed to great projects like DuckDuckGo and Odoo ERP. I also authored a few programming guides. I currently live in Greece and working for Deloitte as a Senior Consultant. In this slide you can find my email as well as my LinkedIn and GitHub username. Please feel free to connect with me, programming is so much better when you do it with company.
- We will start today with an Introduction to Containers and Kubernetes. Then we will see a few things about Google Cloud, their ecosystem and offering. We will delve into Kubernetes to see what it consists of and how it works. Finally, we will see several Kubernetes based services that exist in Google Cloud. These are Cloud Run, Kubernetes Engine, App Engine and Cloud Functions.
- So, let’s start with a few things about Containers & Kubernetes.
- What is a container? A container is a standard unit of software that packages up code and all its dependencies so the application runs quickly and reliably from one computing environment to another. A Docker container image is a lightweight, standalone, executable package of software that includes everything needed to run an application: code, runtime, system tools, system libraries and settings. Comparing Containers and Virtual Machines Containers are an abstraction at the app layer that packages code and dependencies together. Multiple containers can run on the same machine and share the OS kernel with other containers, each running as isolated processes in user space. Containers take up less space than VMs (images are typically tens of MBs in size), can handle more applications and require fewer VMs and Operating systems. Virtual machines (VMs) are an abstraction of physical hardware turning one server into many servers. The hypervisor allows multiple VMs to run on a single machine. Each VM includes a full copy of an operating system, the application, necessary binaries and libraries - taking up tens of GBs. VMs can also be slow to boot. Containers and VMs used together provide a great deal of flexibility in deploying and managing appilcations.
- The concept of containers was started way back in 1979 with UNIX chroot. It’s a UNIX operating-system system call for changing the root directory of a process and it's children to a new location in the filesystem which is only visible to a given process. The idea of this feature is to provide an isolated disk space for each process. Later in 1982 this was added to BSD. FreeBSD Jails is one of the early container technologies for FreeBSD in year 2000. It is an operating-system system call similar to chroot, but included additional process sandboxing features for isolating the filesystem, users, networking, etc. As a result it could provide means of assigning an IP address for each jail, custom software installations and configurations, etc. Linux VServer is another jail mechanism that can be used to securely partition resources on a computer system (file system, CPU time, network addresses and memory). Each partition is called a security context, and the virtualized system within it is called a virtual private server. Solaris Containers were introduced for x86 and SPARC systems, first released publicly in February 2004 in build 51 beta of Solaris 10, and subsequently in the first full release of Solaris 10, 2005. A Solaris Container is a combination of system resource controls and the boundary separation provided by zones. Zones act as completely isolated virtual servers within a single operating system instance. OpenVZ is similar to Solaris Containers and makes use of a patched Linux kernel for providing virtualization, isolation, resource management, and checkpointing. Each OpenVZ container has an isolated file system, users and user groups, a process tree, network, devices, and IPC objects. Process Containers was implemented at Google in 2006 for limiting, accounting, and isolating resource usage (CPU, memory, disk I/O, network, etc.) of a collection of processes. Later on it was renamed to Control Groups to avoid the confusion of the multiple meanings of the term “container” in the Linux kernel context and merged to the Linux kernel 2.6.24. This shows how early Google was involved in container technology and how they have contributed. As explained above, Control Groups AKA cgroups were implemented by Google and added to the Linux Kernel in 2007. LXC stands for LinuX Containers and it is the first, most complete implementation of Linux container manager. It was implemented using cgroups and Linux namespaces. LXC was delivered in liblxc library and provided language bindings for the API in Python3, Python2, Lua, Go, Ruby, and Haskell. In contrast to other container technologies LXC works on vanilla Linux kernel without requiring any patches. Today LXC project is sponsored by Canonical Ltd. Warden was implemented by CloudFoundry in 2011 by using LXC at the initial stage and later on replaced with their own implementation. Unlike LXC, Warden is not tightly coupled to Linux. Rather, it can work on any operating system that can provide ways of isolating environments. It runs as a daemon and provides an API for managing the containers. lmctfy stands for “Let Me Contain That For You”. It is the open source version of Google’s container stack, which provides Linux application containers. Google started this project with the intention of providing guaranteed performance, high resource utilization, shared resources, over-commitment, and near zero overhead with containers. The cAdvisor tool used by Kubernetes today was started as a result of lmctfy project. The initial release of it was made in Oct 2013 and in the year 2015 Google decided to contribute core lmctfy concepts and abstractions to libcontainer. As a result, now no active development is done. The libcontainer project was initially started by Docker and now it has been moved to Open Container Foundation. Docker is the most popular and widely used container management system. It was developed as an internal project at a platform-as-a-service company called dotCloud and later renamed 'Docker'. Similar to Warden, Docker also used LXC at the initial stages and later replaced LXC with its own library called libcontainer. Unlike any other container platform, Docker introduced an entire ecosystem for managing containers. This includes a highly efficient, layered container image model, a global and local container registries, a clean REST API, a CLI, etc. Docker also implemented a container cluster management solution called Docker Swarm. Docker Compose is also a tool for defining and running multi-container Docker applications.
- What is Kubernetes? Kubernetes is an open-source container-orchestration system for automating computer applications deployment, scaling, and management. It was originally designed by Google and is now maintained by the Cloud Native Computing Foundation. It aims to provide a "platform for automating deployment, scaling, and operations of application containers across clusters of hosts". It works with a range of container tools, including Docker. What it can do? Service discovery and load balancing - It can expose a container using the DNS name or using their own IP address. If traffic to a container is high, Kubernetes is able to load balance and distribute the network traffic so that the deployment is stable. Storage Orchestration - allows you to automatically mount a storage system of your choice, such as local storages, public cloud providers, and more. Automated rollouts and rollbacks - You can describe the desired state for your deployed containers using Kubernetes, and it can change the actual state to the desired state at a controlled rate. For example, you can automate Kubernetes to create new containers for your deployment, remove existing containers and adopt all their resources to the new container. Automatic bin packing - You provide Kubernetes with a cluster of nodes that it can use to run containerized tasks. You tell Kubernetes how much CPU and memory (RAM) each container needs. Kubernetes can fit containers onto your nodes to make the best use of your resources. Self-healing - Kubernetes restarts containers that fail, replaces containers, kills containers that don't respond to your user-defined health check, and doesn't advertise them to clients until they are ready to serve. Secret and configuration management - Kubernetes lets you store and manage sensitive information, such as passwords, OAuth tokens, and SSH keys. You can deploy and update secrets and application configuration without rebuilding your container images, and without exposing secrets in your stack configuration.
- Google introduced the Borg System on 2003. It started off as a small-scale project, with about 3-4 people initially in collaboration with a new version of Google’s new search engine. Borg was a large-scale internal cluster management system, which ran hundreds of thousands of jobs, from many thousands of different applications, across many clusters, each with up to tens of thousands of machines. Following Borg, Google introduced the Omega cluster management system on 2013. Omega is a flexible, scalable scheduler for large compute clusters. On 2014 Google introduced Kubernetes as an open source version of Borg. We have the Initial release - first GitHub commit for Kubernetes. The same year Microsoft, RedHat, IBM, Docker and many more joins the Kubernetes community. On 2015 Kubernetes v1.0 gets released. Along with the release, Google partnered with the Linux Foundation to form the Cloud Native Computing Foundation (CNCF). The CNFC aims to build sustainable ecosystems and to foster a community around a constellation of high-quality projects that orchestrate containers as part of a microservices architecture. The same year more companies joined the ecosystem like: Deis, OpenShift, Huawei, and Gondor. On 2016 we have the first release of Helm (the package manager of Kubernetes) and Minikube (a tool that makes it easy to run Kubernetes locally). Also in September 29 of 2016 we have the largest Kubernetes deployment on Google Container Engine ever which is “Pokémon Go”! At the end of the year with the release of Kubernetes 1.5 - Windows Server Support Comes to Kubernetes. 2017 was the Year of Enterprise Adoption & Support GitHub runs on Kubernetes: all web and API requests are served by containers running in Kubernetes clusters deployed on metal cloud. The same year: Oracle joined the Cloud Native Computing Foundation as a platinum member Docker Fully Embraces Kubernetes - developers and operators can build apps with Docker and seamlessly test & deploy them using either Swarm or Kubernetes. Microsoft announced the preview of AKS and AWS announced Elastic Container Service for Kubernetes
- A few words for Google Cloud
- For the past 16 years, Google has been building the world’s fastest, most powerful Cloud Infrastructure on the planet. It operates already in 24 cloud regions and will soon be in another 9.
- When you look at Google Cloud, you’ll see that it's actually part of a much larger ecosystem. This ecosystem consists of open-source software, providers, partners, developers, third-party software, and other cloud providers. Also, Google is a very strong supporter of open-source software.
- A few things about GCP’s shared responsibility model. With blue color the stack level of the user’s responsibility and with the orange the provider’s. Infrastructure as a Service (IaaS) : It provides only a base infrastructure (Virtual machine, Software Define Network, Storage attached). The end user have to configure and manage platform and environment, deploy applications on it. Container as a Service (CaaS): Is a form of container-based virtualization in which container engines, orchestration and the underlying compute resources are delivered to users as a service from a cloud provider. Platform as a Service (PaaS): It provides a platform allowing end user to develop, run, and manage applications without the complexity of building and maintaining the infrastructure. Function as a Service (FaaS): It provides a platform allowing customers to develop, run, and manage application functionalities without the complexity of building and maintaining the infrastructure. Of course Google provides many other service types like SaaS like Gsuite or BaaS like Firebase
- Google Cloud provides services for Compute, Storage & Databases, Networking, Big Data, Developer Tools, Identity & Security, Internet of Things, Cloud AI, Management Tools and Data Transfer. GCP is not the only Platform that exists in order to use Google Cloud Services, Containers or Kubernetes.
- Let’s have a look now at how Kubernetes works and its core components.
- When you deploy Kubernetes, you get a cluster. A Kubernetes cluster consists of a cluster master and one or more nodes, which are the workers of the cluster. The cluster master controls the cluster and can be replicated and distributed for high availability and fault tolerance. The cluster master manages services provided by Kubernetes, such as the Kubernetes API, controllers and schedulers. Users can interact with a cluster using the kubectl commands. Nodes are primarily controlled by the cluster master, but some commands can be run manually. The nodes run an agent called kubelet, which is the service that communicates with the cluster master.
- Pods are single instances of a running process in a cluster that contain at least one container. Multiple containers are used when they need to share resources. Pods use shared networking and storage across containers. Each pod gets a unique IP and set of ports. Containers connect to a port. Multiple containers in a pod connect to different ports and can talk to each other on localhost. Pods are considered ephemeral, they are expected to terminate if a pod is unhealthy, stuck or crashing. The Controller manages scaling and health monitoring. Deployments are sets of identical Pods. The members of the set may change as some Pods are terminated and others are started, but they are all running in the same app. ReplicaSet is a controller used by a deployment that ensures the correct number of identical Pods are running. ReplicaSets are also used to update and delete Pods. Services are objects that provide API endpoints with a stable IP address that allow applications to discover Pods running a particular app. Services update when changes are made to pods, so they maintain an up-to-date list of pods running an application. A StatefulSet allows to have a single pod respond to all calls for a client during a single session. It is assigning a unique identifier to pods so Kubernetes can keep track which pod is used by which client. It is used when an application needs a unique network or persistent storage. Jobs are workloads. They create pods and run them until the application completes. Job specifications are specified in a configuration file and include specifications about the container to use and what command to run. Persistent Volumes provide an API for users and administrators that abstracts details of how storage is provided from how it is consumed. Persistent Volumes is a piece of storage in the cluster that has been provisioned by an administrator or dynamically provisioned using Storage Classes.
- Cloud Run
- Let’s define first what is Serverless Computing. It is a paradigm shift in application development that enables developers to focus on writing code without worrying about Infrastructure. It offers a variety of benefits over traditional computing, including zero server management, no up-front provisioning, auto-scaling, and paying only for the resources used. These advantages make Serverless ideal for use cases like stateless HTTP applications, Web, Mobile, IoT Back-ends, Batch and Stream Data Processing, Chatbots, and more.
- Container as a Service has two services which are Cloud Run and Kubernetes Engine. Cloud Run is a managed compute platform that enables you to run stateless containers that are invocable via web requests or Pub/Sub events. Cloud Run is serverless: it abstracts away all infrastructure management, so you can focus on your code. It is built from Knative, letting you choose to run your containers either fully managed with Cloud Run, in your Google Kubernetes Engine cluster, or in workloads on-premises with Cloud Run for Anthos.
- Cloud Run is an ideal serverless platform for stateless containerized microservices that don’t require Kubernetes features like namespaces, co-location of containers in pods or node allocation and management. The managed serverless compute platform Cloud Run provides a number of features like: 1. Easy deployment of microservices. A containerized microservice can be deployed with a single command without requiring any additional service-specific configuration. 2. Each microservice is implemented as a Docker image, Cloud Run’s unit of deployment. 3. A microservice deployed into managed Cloud Run scales automatically based on the number of incoming requests, without having to configure or manage a full-fledged Kubernetes cluster. Managed Cloud Run scales to zero if there are no requests. 4. Cloud Run is based on containers, so you can write code in any language, using any binary and framework. 5. It comes with a simple command line and user interface and integrates with Cloud Code and Cloud Build for CI/CD. 6. Of course it supports strict container isolation, custom domains and it provides an out of the box HTTPS endpoint with TLS termination self handled.
- Kubernetes Engine
- Kubernetes Engine is a secured and managed Kubernetes service with auto-scaling and multi-cluster support. It starts easily with many “single click” options. It offers auto-repair and auto-upgrade, vulnerability scanning and data encryption. When it comes to managed Kubernetes services, Google Kubernetes Engine (GKE) is a great choice if you are looking for a container orchestration platform that offers advanced scalability and configuration flexibility. GKE gives you complete control over every aspect of container orchestration, from networking, to storage, to how you set up observability—in addition to supporting stateful applications. However, if your application does not need that level of cluster configuration and monitoring, then fully managed Cloud Run might be the right solution.
- Some other considerable features of Kubernetes Engine are: Control access in the cluster with your Google accounts and role permissions. Reserve an IP address range for your cluster, allowing your cluster IPs to coexist with private network IPs via Google Cloud VPN. One click configurations for Cloud Logging and Cloud Monitoring Fully managed clusters and automatic updates with the latest release version of Kubernetes. When auto repair is enabled, if a node fails a health check, Kubernetes Engine initiates a repair process for that node. Resource limits on CPU and memory per container It provides a private container registry for your Docker images Cloud Console offers dashboards for your project's clusters and their resources. You can use these dashboards to view, inspect, manage, and delete resources in your clusters. It offers load-balancing to distribute incoming requests across multiple regions And it supports both Linux nodes and Windows Servers
- App Engine
- Each Google Cloud project can contain 1 App Engine application. You can scale up to 7 billion requests per day and automatically scale down when traffic subsides. App Engine is well suited for web and mobile applications and supports most popular programming languages, like Node.js, Java, Ruby, C#, Go, Python, PHP or bring your own language runtime. Custom runtimes allow you to bring any library and framework to App Engine by supplying a Docker container. It gives you the option to choose the storage you need: a traditional MySQL database using Cloud SQL, a schemaless NoSQL datastore, or object storage using Cloud Storage. It also offers application diagnostics and tools to diagnose and fix bugs with Cloud Monitoring, Cloud Logging, Cloud Debugger and Error Reporting. It allows to host different versions of your application and create development, test, staging, and production environments. It gives you the option to route incoming requests to different application versions and do incremental feature rollouts. You can also define access rules with App Engine firewall and manage SSL/TLS certificates. App Engine applications consist of an application, a service, a version and an instance. An application has at least one service, which is the code executed in the App Engine environment. Under the Service, there is a versioning system that holds all the versions of your application. When a Version executes it creates an instance of the app. Services are typically structured to perform a single function and complex applications are made of several microservices.
- Because we mentioned App Engine’s use of Docker containers, you may be wondering how App Engine compares to Kubernetes Engine. Here’s a side-by-side comparison of App Engine with Kubernetes Engine. App Engine comes in 2 editions – Flexible and Standard. The Standard edition is for people who want the service to take maximum control of their application’s deployment and scaling. Kubernetes Engine on the other hand, gives the application owner the full flexibility of Kubernetes. App Engine Flexible is in between. Also, App Engine Environment treats containers as a means to an end. But for Kubernetes Engine, containers are a fundamental organizing principle.
- Finally let’s have a look at Cloud Functions
- Google Cloud Functions is a serverless execution environment for building and connecting cloud services. It is a lightweight computing option for event-driven processing. It supports Node.js, Python, Go and Java. The functions execute in a secure, isolated environment and they are code independent and stateless With Cloud Functions you write simple, single-purpose functions that are attached to events emitted from your cloud infrastructure and services.
- Cloud Functions lets you treat all Google and third-party cloud services as building blocks. You can connect and extend them with code, and rapidly move from concept to production with end-to-end solutions and complex workflows. Further, they integrate with third-party services that offer webhook integrations to quickly extend your application with powerful capabilities. Cloud Functions abstracts away all the underlying infrastructure and scales automatically. An event is an action in Google Cloud, such as a file upload to the Cloud Storage. GCP supports events in Cloud Storage (upload, delete or archive), Cloud Pub/Sub (it has an event for publishing a message), HTTP (by calling a specific function), Firebase (in the Firebase DB by using triggers) and Logging (by forwarding logs to a Pub/Sub topic). For every Cloud Function, you can define a trigger and triggers are associated with functions.
- Let’s have a chat before we go through the end of this presentation. Who would like to start with a question or comment?
- Thank you very much for joining me. I hope you enjoyed this presentation and now have an idea of where to start if you ever need to use Kubernetes in GCP. You can also find my article “Google Cloud Platform handbook for enthusiasts” on LinkedIn where you can have a broader look at GCP services. Take care and keep safe.