Kubernetes Management Design Patterns (eBook)

With Docker, CoreOS Linux, and Other Platforms

Deepak Vohra (Autor)

eBook Download: PDF

2017 | 1st ed.
XX, 399 Seiten
Apress (Verlag)
978-1-4842-2598-1 (ISBN)

Infos

Take container cluster management to the next level; learn how to administer and configure Kubernetes on CoreOS; and apply suitable management design patterns such as Configmaps, Autoscaling, elastic resource usage, and high availability.  Some of the other features discussed are logging, scheduling, rolling updates, volumes, service types, and multiple cloud provider zones.

 

The atomic unit of modular container service in Kubernetes is a Pod, which is a group of containers with a common filesystem and networking. The Kubernetes Pod abstraction enables design patterns for containerized applications similar to object-oriented design patterns. Containers provide some of the same benefits as software objects such as modularity or packaging, abstraction, and reuse.

CoreOS Linux is used in the majority of the chapters and other platforms discussed are CentOS with OpenShift, Debian 8 (jessie) on AWS, and Debian 7 for Google Container Engine.  

CoreOS is the main focus becayse Docker is pre-installed on CoreOS out-of-the-box. CoreOS: 

• Supports most cloud providers (including Amazon AWS EC2 and Google Cloud Platform) and virtualization platforms (such as VMWare and VirtualBox)
  
• Provides Cloud-Config for declaratively configuring for OS items such as network configuration (flannel), storage (etcd), and user accounts 
  
• Provides a production-level infrastructure for containerized applications including automation, security, and scalability
  
• Leads the drive for container industry standards and founded appc 
  
• Provides the most advanced container registry, Quay  
  

 

Docker was made available as open source in March 2013 and has become the most commonly used containerization platform. Kubernetes was open-sourced in June 2014 and has become the most widely used container cluster manager.  The first stable version of CoreOS Linux was made available in July 2014 and since has become one of the most commonly used operating system for containers. 

 

What You'll Learn

• Use Kubernetes with Docker
  
• Create a Kubernetes cluster on CoreOS on AWS
  
• Apply cluster management design patterns
  
• Use multiple cloud provider zones
  
• Work with Kubernetes and tools like Ansible
  
• Discover the Kubernetes-based PaaS platform OpenShift
  
• Create a high availability website
  
• Build a high availability Kubernetes master cluster
  
• Use volumes, configmaps, services, autoscaling, and rolling updates
  
• Manage compute resources
  
• Configure logging and scheduling
  

Who This Book Is For

Linux admins, CoreOS admins, application developers, and container as a service (CAAS) developers. Some pre-requisite knowledge of Linux and Docker is required. Introductory knowledge of Kubernetes is required such as creating a cluster, creating a Pod, creating a service, and creating and scaling a replication controller. For introductory Docker and Kubernetes information, refer to Pro Docker (Apress) and Kubernetes Microservices with Docker (Apress). Some pre-requisite knowledge about using Amazon Web Services (AWS) EC2, CloudFormation, and VPC is also required. 

Deepak Vohra is an Oracle Certified Associate and a Sun Certified Java Programmer. Deepak has published in Oracle Magazine, OTN, IBM developerWorks, ONJava, DevSource,  WebLogic Developer's Journal, XML Journal, Java Developer's Journal, FTPOnline, and devx.

Inhalt

Contents at a Glance 4
Contents 6
About the Author 14
About the Technical Reviewer 15
Introduction 16
Part I: Platforms 20
Chapter 1: Kubernetes on AWS 21
Problem 21
Solution 21
Overview 21
Setting the Environment 22
Configuring AWS 25
Starting the Kubernetes Cluster 29
Testing the Cluster 35
Configuring the Cluster 36
Stopping the Cluster 39
Summary 40
Chapter 2: Kubernetes on CoreOS on AWS 41
Problem 41
Solution 41
Overview 42
Setting the Environment 43
Configuring AWS Credentials 43
Installing Kube-aws 43
Setting Up Cluster Parameters 45
Creating a KMS Key 46
Setting Up an External DNS Name 47
Creating the Cluster 47
Creating an Asset Directory 47
Initializing the Cluster CloudFormation 48
Rendering Contents of the Asset Directory 48
Customizing the Cluster 49
Validating the CloudFormation Stack 52
Launching the Cluster CloudFormation 52
Configuring DNS 53
Accessing the Cluster 57
Testing the Cluster 59
Summary 65
Chapter 3: Kubernetes on Google Cloud Platform 66
Problem 66
Solution 66
Overview 66
Setting the Environment 67
Creating a Project on Google Cloud Platform 67
Enabling Permissions 72
Enabling the Compute Engine API 73
Creating a VM Instance 79
Connecting to the VM Instance 83
Reserving a Static External IP Address 84
Creating a Kubernetes Cluster 84
Creating a Kubernetes Application and Service 88
Stopping the Cluster 92
Using Kubernetes with Google Container Engine 94
Creating a Google Container Cluster 94
Connecting to the Google Cloud Shell 97
Configuring kubectl 97
Testing the Kubernetes Cluster 98
Summary 104
Part II: Administration and Configuration 105
Chapter 4: Using Multiple Zones 106
Problem 106
Solution 107
Overview 108
Setting the Environment 108
Initializing a CloudFormation 110
Configuring cluster.yaml for Multiple Zones 110
Launching the CloudFormation 114
Configuring External DNS 115
Running a Kubernetes Application 116
Using Multiple Zones on AWS 118
Summary 131
Chapter 5: Using the Tectonic Console 132
Problem 132
Solution 132
Overview 133
Setting the Environment 133
Downloading the Pull Secret and the Tectonic Console Manifest 135
Installing the Pull Secret and the Tectonic Console Manifest 137
Accessing the Tectonic Console 138
Using the Tectonic Console 139
Removing the Tectonic Console 149
Summary 149
Chapter 6: Using Volumes 150
Problem 150
Solution 150
Overview 151
Setting the Environment 152
Creating an AWS Volume 154
Using an awsElasticBlockStore Volume 156
Creating a Git Repo 160
Using a gitRepo Volume 164
Summary 167
Chapter 7: Using Services 168
Problem 168
Solution 169
Overview 169
Setting the Environment 170
Creating a ClusterIP Service 171
Creating a NodePort Service 174
Creating a LoadBalancer Service 181
Summary 185
Chapter 8: Using Rolling Updates 186
Problem 186
Solution 186
Overview 187
Setting the Environment 188
Rolling Update with an RC Definition File 189
Rolling Update by Updating the Container Image 192
Rolling Back an Update 199
Using Only Either File or Image 201
Multiple-Container Pods 201
Rolling Update to a Deployment 201
Summary 213
Chapter 9: Scheduling Pods on Nodes 214
Problem 214
Solution 214
Overview 215
Defining a Scheduling Policy 215
Setting the Environment 217
Using the Default Scheduler 218
Scheduling Pods without a Node Selector 228
Setting Node Labels 228
Scheduling Pods with a Node Selector 229
Setting Node Affinity 235
Setting requiredDuringSchedulingIgnoredDuringExecution 237
Setting preferredDuringSchedulingIgnoredDuringExecution 244
Summary 251
Chapter 10: Configuring Compute Resources 252
Problem 252
Solution 252
Overview 253
Types of Compute Resources 254
Resource Requests and Limits 255
Quality of Service 257
Setting the Environment 258
Finding Node Capacity 259
Creating a Pod with Resources Specified 260
Limit on Number of Pods 267
Overcommitting Resource Limits 269
Reserving Node Resources 269
Summary 271
Chapter 11: Using ConfigMaps 272
Problem 272
Solution 272
Overview 272
Kubectl create configmap Command 273
Setting the Environment 273
Creating ConfigMaps from Directories 274
Creating ConfigMaps from Files 281
Creating ConfigMaps from Literal Values 285
Consuming a ConfigMap in a Volume 289
Summary 292
Chapter 12: Using Resource Quotas 293
Problem 293
Solution 293
Overview 294
Setting the Environment 295
Defining Compute Resource Quotas 296
Exceeding Compute Resource Quotas 298
Defining Object Quotas 302
Exceeding Object Quotas 304
Defining Best-Effort Scope Quotas 308
Summary 312
Chapter 13: Using Autoscaling 313
Problem 313
Solution 313
Overview 314
Setting the Environment 314
Running a PHP Apache Server Deployment 316
Creating a Service 316
Creating a Horizontal Pod Autoscaler 317
Increasing Load 320
Summary 322
Chapter 14: Configuring Logging 323
Problem 323
Solution 323
Overview 324
Setting the Environment 325
Getting the Logs Generated by Default Logger 325
Docker Log Files 327
Cluster-Level Logging with Elasticsearch and Kibana 328
Starting a Replication Controller 329
Starting Elastic Search 332
Starting Fluentd to Collect Logs 336
Starting Kibana 338
Summary 345
Part III: High Availability 346
Chapter 15: Using an HA Master with OpenShift 347
Problem 347
Solution 347
Overview 348
Setting the Environment 348
Installing the Credentials 350
Installing the Network Manager 351
Installing OpenShift via Ansible on the Client Machine 351
Configuring Ansible 354
Running the Ansible Playbook 358
Testing the Cluster 359
Testing the High Availability 361
Summary 365
Chapter 16: Developing a Highly Available Website 366
Problem 366
Solution 366
Overview 367
Setting the Environment 368
Creating CloudFormations 368
Configuring External DNS 372
Creating a Kubernetes Service 373
Creating an AWS Route 53 Service 378
Creating a Hosted Zone 379
Configuring Name Servers on a Domain Name 380
Creating Record Sets 385
Testing High Availability 395
Summary 403
Index 404

Produkt-Details

• Erscheint lt. Verlag: 20.1.2017
• Zusatzinfo: XX, 399 p. 560 illus., 500 illus. in color.
• Verlagsort: Berkeley
• Sprache: englisch
• Themenwelt: Informatik ► Betriebssysteme / Server ► Unix / Linux
• Themenwelt: Informatik ► Betriebssysteme / Server ► Windows
• Themenwelt: Mathematik / Informatik ► Informatik ► Programmiersprachen / -werkzeuge
• Themenwelt: Informatik ► Software Entwicklung ► Objektorientierung
• Themenwelt: Informatik ► Weitere Themen ► Hardware
• Schlagworte: Admin • clusters • CoreOS • Docker • IT • Linux • Server
• ISBN-10: 1-4842-2598-8 / 1484225988
• ISBN-13: 978-1-4842-2598-1 / 9781484225981