The Kubernetes Operator Framework Book

Cover
Title Page
Copyright and Credits
Dedication
Contributors
Table of Contents
Preface
Part 1: Essentials of Operators and the Operator Framework
Chapter 1: Introducing the Operator Framework
	Technical requirements
	Managing clusters without Operators
		Demonstrating on a sample application
		Reacting to changing cluster states
	Introducing the Operator Framework
		Exploring Kubernetes controllers
		Knowing key terms for Operators
		Putting it all together
	Developing with the Operator SDK
	Managing Operators with OLM
	Distributing Operators on OperatorHub.io
	Defining Operator functions with the Capability Model
	Using Operators to manage applications
		Summarizing the Operator Framework
		Applying Operator capabilities
	Summary
Chapter 2: Understanding How Operators Interact with Kubernetes
	Interacting with Kubernetes cluster resources
		Pods, ReplicaSets, and Deployments
		Custom resource definitions
		ServiceAccounts, roles, and RoleBindings (RBAC)
		Namespaces
	Identifying users and maintainers
		Cluster administrators
		Cluster users
		End users and customers
		Maintainers
	Designing beneficial features for your operator
	Planning for changes in your Operator
		Starting small
		Iterating effectively
		Deprecating gracefully
	Summary
Part 2: Designing and Developing an Operator
Chapter 3: Designing an Operator – CRD, API, and Target Reconciliation
	Describing the problem
	Designing an API and a CRD
		Following the Kubernetes API design conventions
		Understanding a CRD schema
		Example Operator CRD
	Working with other required resources
	Designing a target reconciliation loop
		Level- versus edge-based event triggering
		Designing reconcile logic
	Handling upgrades and downgrades
	Using failure reporting
		Reporting errors with logging
		Reporting errors with status updates
		Reporting errors with events
	Summary
Chapter 4: Developing an Operator with the Operator SDK
	Technical requirements
	Setting up your project
	Defining an API
	Adding resource manifests
		Additional manifests and BinData
	Writing a control loop
	Troubleshooting
		General Kubernetes resources
		Operator SDK resources
		Kubebuilder resources
	Summary
Chapter 5: Developing an Operator – Advanced Functionality
	Technical requirements
	Understanding the need for advanced functionality
	Reporting status conditions
		Operator CRD conditions
		Using the OLM OperatorCondition
	Implementing metrics reporting
		Adding a custom service metric
		RED metrics
	Implementing leader election
	Adding health checks
	Summary
Chapter 6: Building and Deploying Your Operator
	Technical requirements
	Building a container image
		Building the Operator locally
		Building the Operator image with Docker
	Deploying in a test cluster
	Pushing and testing changes
		Installing and configuring kube-prometheus
		Redeploying the Operator with metrics
		Key takeaways
	Troubleshooting
		Makefile issues
		kind
		Docker
		Metrics
		Additional errors
	Summary
Part 3: Deploying and Distributing Operators for Public Use
Chapter 7: Installing and Running Operators with the Operator Lifecycle Manager
	Technical requirements
	Understanding the OLM
		Installing the OLM in a Kubernetes cluster
		Interacting with the OLM
	Running your Operator
		Generating an Operator's bundle
		Exploring the bundle files
		Building a bundle image
		Pushing a bundle image
		Deploying an Operator bundle with the OLM
	Working with OperatorHub
		Installing Operators from OperatorHub
		Submitting your own Operator to OperatorHub
	Troubleshooting
		OLM support
		OperatorHub support
	Summary
Chapter 8: Preparing for Ongoing Maintenance of Your Operator
	Technical requirements
	Releasing new versions of your Operator
		Adding an API version to your Operator
		Updating the Operator CSV version
		Releasing a new version on OperatorHub
	Planning for deprecation and backward compatibility
		Revisiting Operator design
		Starting small
		Iterating effectively
		Deprecating gracefully
	Complying with Kubernetes standards for changes
		Removing APIs
		API conversion
		API lifetime
	Aligning with the Kubernetes release timeline
		Overview of a Kubernetes release
		Start of release
		Enhancements Freeze
		Call for Exceptions
		Code Freeze
		Test Freeze
		GA release/Code Thaw
		Retrospective
	Working with the Kubernetes community
	Summary
Chapter 9: Diving into FAQs and Future Trends
	FAQs about the Operator Framework
		What is an Operator?
		What benefit do Operators provide to a Kubernetes cluster?
		How are Operators different from other Kubernetes controllers?
		What is the Operator Framework?
		What is an Operand?
		What are the main components of the Operator Framework?
		What programming languages can Operators be written in?
		What is the Operator Capability Model?
	FAQs about Operator design, CRDs, and APIs
		How does an Operator interact with Kubernetes?
		What cluster resources does an Operator act on?
		What is a CRD?
		How is a CRD different from a CR object?
		What Kubernetes namespaces do Operators run within?
		How do users interact with an Operator?
		How can you plan for changes early in an Operator's lifecycle?
		How does an Operator's API relate to its CRD?
		What are the conventions for an Operator API?
		What is a structural CRD schema?
		What is OpenAPI v3 validation?
		What is Kubebuilder?
		What is a reconciliation loop?
		What is the main function of an Operator's reconciliation loop?
		What are the two kinds of event triggering?
		What is a ClusterServiceVersion (CSV)?
		How can Operators handle upgrades and downgrades?
		How can Operators report failures?
		What are status conditions?
		What are Kubernetes events?
	FAQs about the Operator SDK and coding controller logic
		What is the Operator SDK?
		How can operator-sdk scaffold a boilerplate Operator project?
		What does a boilerplate Operator project contain?
		How can you create an API with operator-sdk?
		What does a basic Operator API created with operator-sdk look like?
		What other code is generated by operator-sdk?
		What do Kubebuilder markers do?
		How does the Operator SDK generate Operator resource manifests?
		How else can you customize generated Operator manifests?
		What are go-bindata and go:embed?
		What is the basic structure of a control/reconciliation loop?
		How does a control loop function access Operator config settings?
		What information does a status condition report?
		What are the two basic kinds of metrics?
		How can metrics be collected?
		What are RED metrics?
		What is leader election?
		What are the two main strategies for leader election?
		What are health and ready checks?
	FAQs about OperatorHub and the OLM
		What are the different ways to compile an Operator?
		How does a basic Operator SDK project build a container image?
		How can an Operator be deployed in a Kubernetes cluster?
		What is the OLM?
		What benefit does running an Operator with the OLM provide?
		How do you install the OLM in a cluster?
		What does the operator-sdk olm status command show?
		What is an Operator bundle?
		How do you generate a bundle?
		What is a bundle image?
		How do you build a bundle image?
		How do you deploy a bundle with the OLM?
		What is OperatorHub?
		How do you install an Operator from OperatorHub?
		How do you submit an Operator to OperatorHub?
	Future trends in the Operator Framework
		How do you release a new version of an Operator?
		When is it appropriate to add a new API version?
		How do you add a new API version?
		What is an API conversion?
		How do you convert between two versions of an API?
		What is a conversion webhook?
		How do you add a conversion webhook to an Operator?
		What is kube-storage-version-migrator?
		How do you update an Operator's CSV?
		What are upgrade channels?
		How do you publish a new version on OperatorHub?
		What is the Kubernetes deprecation policy?
		How can API elements be removed in the Kubernetes deprecation policy?
		How long are API versions generally supported?
		How long is the Kubernetes release cycle?
		What is Enhancements Freeze?
		What is Code Freeze?
		What is Retrospective?
		How do Kubernetes community standards apply to Operator development?
	Summary
Chapter 10: Case Study for Optional Operators – the Prometheus Operator
	A real-world use case
		Prometheus overview
		Installing and running Prometheus
		Configuring Prometheus
		Summarizing the problems with manual Prometheus
	Operator design
		CRDs and APIs
		Reconciliation logic
	Operator distribution and development
	Updates and maintenance
	Summary
Chapter 11: Case Study for Core Operator – Etcd Operator
	Core Operators – extending the Kubernetes platform
		RBAC Manager
		The Kube Scheduler Operator
		The etcd Operator
	etcd Operator design
		CRDs
		Reconciliation logic
		Failure recovery
	Stability and safety
	Upgrading Kubernetes
	Summary
Index
About Packt
Other Books You May Enjoy