Kubernetes: Up and Running. 3rd Edition Brendan Burns, Joe Beda, Kelsey Hightower

Kubernetes: Up and Running. 3rd Edition Brendan Burns, Joe Beda, Kelsey Hightower - okladka książki

Autorzy:: Brendan Burns, Joe Beda, Kelsey Hightower
Wydawnictwo:: O'Reilly Media (Z chęcią przeczytam książkę w języku polskim)
Ocena:: 1.0/6 Opinie: 1
Stron:: 328
Dostępne formaty:: ePub

Mobi

Ebook 203,15 zł najniższa cena z 30 dni

~~239,00 zł~~ (-15%)
203,15 zł

Dodaj do koszyka lub Kup na prezent Kup 1-kliknięciem

203,15 zł najniższa cena z 30 dni

Przenieś na półkę

Do przechowalni

In just five years, Kubernetes has radically changed the way developers and ops personnel build, deploy, and maintain applications in the cloud. With this book's updated third edition, you'll learn how this popular container orchestrator can help your company achieve new levels of velocity, agility, reliability, and efficiency--whether you're new to distributed systems or have been deploying cloud native apps for some time.

Brendan Burns, Joe Beda, Kelsey Hightower, and Lachlan Evenson--who have worked on Kubernetes at Google and beyond--explain how this system fits into the life cycle of a distributed application. Software developers, engineers, and architects will learn ways to use tools and APIs to automate scalable distributed systems for online services, machine learning applications, or even a cluster of Raspberry Pi computers.

This guide shows you how to:

Create a simple cluster to learn how Kubernetes works
Dive into the details of deploying an application using Kubernetes
Learn specialized objects in Kubernetes, such as DaemonSets, jobs, ConfigMaps, and secrets
Explore deployments that tie together the lifecycle of a complete application
Get practical examples of how to develop and deploy real-world applications in Kubernetes

Wybrane bestsellery

O autorach książki

dr Brendan Burns specjalizuje się w projektowaniu dużych aplikacji i programowaniu obliczeń w chmurze. Jest też współzałożycielem projektu open source Kubernetes. Obecnie pracuje w Microsofcie, gdzie zajmuje się platformą Azure, natomiast wcześniej pracował w Google Cloud Platform. Kiedyś zajmował się również infrastrukturą wyszukiwarek internetowych Google.

Joe Beda jest jednym z inicjatorów projektu Kubernetes, pełnił kluczową funkcję w tworzeniu Google Compute Engine (usługi VM w chmurze Google). Pracuje jako dyrektor techniczny firmy Heptio.

Kelsey Hightower zajmował się różnymi technikami informatycznymi. Jest orędownikiem idei open source i prostych narzędzi, które ułatwiają ludziom życie. Namiętnie pisze kod w Go i prowadzi warsztaty techniczne

Brendan Burns, Joe Beda, Kelsey Hightower - pozostałe książki

Ebooka "Kubernetes: Up and Running. 3rd Edition" przeczytasz na:

czytnikach Inkbook, Kindle, Pocketbook, Onyx Boox i innych
systemach Windows, MacOS i innych

systemach Windows, Android, iOS, HarmonyOS
na dowolnych urządzeniach i aplikacjach obsługujących formaty: PDF, EPub, Mobi

Masz pytania? Zajrzyj do zakładki Pomoc »

Oceny i opinie klientów: Kubernetes: Up and Running. 3rd Edition Brendan Burns, Joe Beda, Kelsey Hightower

(1)

6
(0)
5
(0)
4
(0)
3
(0)
2
(0)
1
(1)

1.0

Opinia: anonimowa Opinia dodana: 2022-12-16 Ocena: 1

Opinia potwierdzona zakupem

Opinia dotyczy produktu: ebook

Czy opinia była pomocna:

TAK (0) NIE (2)

Brak wersji PDF w przypadku książek technicznych to katastrofa, w szczególności, że inni dystrybutorzy mają ten format w ofercie.

Szczegóły książki

ISBN Ebooka:: 978-10-981-1015-4, 9781098110154
Data wydania ebooka :: 2022-08-02 Data wydania ebooka często jest dniem wprowadzenia tytułu do sprzedaży i może nie być równoznaczna z datą wydania książki papierowej. Dodatkowe informacje możesz znaleźć w darmowym fragmencie. Jeśli masz wątpliwości skontaktuj się z nami sklep@ebookpoint.pl.
Język publikacji:: angielski
Rozmiar pliku ePub:: 2.6MB
Rozmiar pliku Mobi:: 6.2MB

Zgłoś erratę

Kategorie

Kliknij, aby zgłosić błędnie przypisaną kategorię »

Informatyka » Systemy operacyjne » Wirtualizacja
Informatyka » Serwery internetowe » Inne

Spis treści książki

Preface
- Who Should Read This Book
- Why We Wrote This Book
- Why We Updated This Book
- A Word on Cloud Native Applications Today
- Navigating This Book
- Online Resources
- Conventions Used in This Book
- Using Code Examples
- OReilly Online Learning
- How to Contact Us
- Acknowledgments
1. Introduction
- Velocity
  - The Value of Immutability
  - Declarative Configuration
  - Self-Healing Systems
- Scaling Your Service and Your Teams
  - Decoupling
  - Easy Scaling for Applications and Clusters
  - Scaling Development Teams with Microservices
  - Separation of Concerns for Consistency and Scaling
- Abstracting Your Infrastructure
- Efficiency
- Cloud Native Ecosystem
- Summary
2. Creating and Running Containers
- Container Images
- Building Application Images with Docker
  - Dockerfiles
  - Optimizing Image Sizes
  - Image Security
- Multistage Image Builds
- Storing Images in a Remote Registry
- The Container Runtime Interface
  - Running Containers with Docker
  - Exploring the kuard Application
  - Limiting Resource Usage
    - Limiting memory resources
    - Limiting CPU resources
- Cleanup
- Summary
3. Deploying a Kubernetes Cluster
- Installing Kubernetes on a Public Cloud Provider
  - Installing Kubernetes with Google Kubernetes Engine
  - Installing Kubernetes with Azure Kubernetes Service
  - Installing Kubernetes on Amazon Web Services
- Installing Kubernetes Locally Using minikube
- Running Kubernetes in Docker
- The Kubernetes Client
  - Checking Cluster Status
  - Listing Kubernetes Nodes
- Cluster Components
  - Kubernetes Proxy
  - Kubernetes DNS
  - Kubernetes UI
- Summary
4. Common kubectl Commands
- Namespaces
- Contexts
- Viewing Kubernetes API Objects
- Creating, Updating, and Destroying Kubernetes Objects
- Labeling and Annotating Objects
- Debugging Commands
- Cluster Management
- Command Autocompletion
- Alternative Ways of Viewing Your Cluster
- Summary
5. Pods
- Pods in Kubernetes
- Thinking with Pods
- The Pod Manifest
  - Creating a Pod
  - Creating a Pod Manifest
- Running Pods
  - Listing Pods
  - Pod Details
  - Deleting a Pod
- Accessing Your Pod
  - Getting More Information with Logs
  - Running Commands in Your Container with exec
  - Copying Files to and from Containers
- Health Checks
  - Liveness Probe
  - Readiness Probe
  - Startup Probe
  - Advanced Probe Configuration
  - Other Types of Health Checks
- Resource Management
  - Resource Requests: Minimum Required Resources
  - Capping Resource Usage with Limits
- Persisting Data with Volumes
  - Using Volumes with Pods
  - Different Ways of Using Volumes with Pods
- Putting It All Together
- Summary
6. Labels and Annotations
- Labels
  - Applying Labels
  - Modifying Labels
  - Label Selectors
  - Label Selectors in API Objects
  - Labels in the Kubernetes Architecture
- Annotations
- Cleanup
- Summary
7. Service Discovery
- What Is Service Discovery?
- The Service Object
  - Service DNS
  - Readiness Checks
- Looking Beyond the Cluster
- Load Balancer Integration
- Advanced Details
  - Endpoints
  - Manual Service Discovery
  - kube-proxy and Cluster IPs
  - Cluster IP Environment Variables
- Connecting with Other Environments
  - Connecting to Resources Outside of a Cluster
  - Connecting External Resources to Services Inside a Cluster
- Cleanup
- Summary
8. HTTP Load Balancing with Ingress
- Ingress Spec Versus Ingress Controllers
- Installing Contour
  - Configuring DNS
  - Configuring a Local hosts File
- Using Ingress
  - Simplest Usage
  - Using Hostnames
  - Using Paths
  - Cleanup
- Advanced Ingress Topics and Gotchas
  - Running Multiple Ingress Controllers
  - Multiple Ingress Objects
  - Ingress and Namespaces
  - Path Rewriting
  - Serving TLS
- Alternate Ingress Implementations
- The Future of Ingress
- Summary
9. ReplicaSets
- Reconciliation Loops
- Relating Pods and ReplicaSets
  - Adopting Existing Containers
  - Quarantining Containers
- Designing with ReplicaSets
- ReplicaSet Spec
  - Pod Templates
  - Labels
- Creating a ReplicaSet
- Inspecting a ReplicaSet
  - Finding a ReplicaSet from a Pod
  - Finding a Set of Pods for a ReplicaSet
- Scaling ReplicaSets
  - Imperative Scaling with kubectl scale
  - Declaratively Scaling with kubectl apply
  - Autoscaling a ReplicaSet
- Deleting ReplicaSets
- Summary
10. Deployments
- Your First Deployment
- Creating Deployments
- Managing Deployments
- Updating Deployments
  - Scaling a Deployment
  - Updating a Container Image
  - Rollout History
- Deployment Strategies
  - Recreate Strategy
  - RollingUpdate Strategy
    - Managing multiple versions of your service
    - Configuring a rolling update
  - Slowing Rollouts to Ensure Service Health
- Deleting a Deployment
- Monitoring a Deployment
- Summary
11. DaemonSets
- DaemonSet Scheduler
- Creating DaemonSets
- Limiting DaemonSets to Specific Nodes
  - Adding Labels to Nodes
  - Node Selectors
- Updating a DaemonSet
- Deleting a DaemonSet
- Summary
12. Jobs
- The Job Object
- Job Patterns
  - One Shot
  - Parallelism
  - Work Queues
    - Starting a work queue
    - Loading up the queue
    - Creating the consumer job
    - Cleanup
- CronJobs
- Summary
13. ConfigMaps and Secrets
- ConfigMaps
  - Creating ConfigMaps
  - Using a ConfigMap
- Secrets
  - Creating Secrets
  - Consuming Secrets
  - Private Container Registries
- Naming Constraints
- Managing ConfigMaps and Secrets
  - Listing
  - Creating
  - Updating
    - Update from file
    - Re-create and update
    - Edit current version
    - Live updates
- Summary
14. Role-Based Access Control for Kubernetes
- Role-Based Access Control
  - Identity in Kubernetes
  - Understanding Roles and Role Bindings
  - Roles and Role Bindings in Kubernetes
    - Verbs for Kubernetes roles
    - Using built-in roles
    - Auto-reconciliation of built-in roles
- Techniques for Managing RBAC
  - Testing Authorization with can-i
  - Managing RBAC in Source Control
- Advanced Topics
  - Aggregating ClusterRoles
  - Using Groups for Bindings
- Summary
15. Service Meshes
- Encryption and Authentication with Mutal TLS
- Traffic Shaping
- Introspection
- Do You Really Need a Service Mesh?
- Introspecting a Service Mesh Implementation
- Service Mesh Landscape
- Summary
16. Integrating Storage Solutions and Kubernetes
- Importing External Services
  - Services Without Selectors
  - Limitations of External Services: Health Checking
- Running Reliable Singletons
  - Running a MySQL Singleton
  - Dynamic Volume Provisioning
- Kubernetes-Native Storage with StatefulSets
  - Properties of StatefulSets
  - Manually Replicated MongoDB with StatefulSets
  - Automating MongoDB Cluster Creation
  - Persistent Volumes and StatefulSets
  - One Final Thing: Readiness Probes
- Summary
17. Extending Kubernetes
- What It Means to Extend Kubernetes
- Points of Extensibility
- Patterns for Custom Resources
  - Just Data
  - Compilers
  - Operators
  - Getting Started
- Summary
18. Accessing Kubernetes from Common Programming Languages
- The Kubernetes API: A Clients Perspective
  - OpenAPI and Generated Client Libraries
  - But What About kubectl x?
- Programming the Kubernetes API
  - Installing the Client Libraries
  - Authenticating to the Kubernetes API
  - Accessing the Kubernetes API
  - Putting It All Together: Listing and Creating Pods in Python, Java, and .NET
  - Creating and Patching Objects
  - Watching Kubernetes APIs for Changes
  - Interacting with Pods
  - Summary
19. Securing Applications in Kubernetes
- Understanding SecurityContext
  - SecurityContext Challenges
- Pod Security
  - What Is Pod Security?
  - Applying Pod Security Standards
- Service Account Management
- Role-Based Access Control
- RuntimeClass
- Network Policy
- Service Mesh
- Security Benchmark Tools
- Image Security
- Summary
20. Policy and Governance for Kubernetes Clusters
- Why Policy and Governance Matter
- Admission Flow
- Policy and Governance with Gatekeeper
  - What Is Open Policy Agent?
  - Installing Gatekeeper
  - Configuring Policies
  - Understanding Constraint Templates
  - Creating Constraints
  - Audit
  - Mutation
  - Data Replication
  - Metrics
  - Policy Library
- Summary
21. Multicluster Application Deployments
- Before You Even Begin
- Starting at the Top with a Load-Balancing Approach
- Building Applications for Multiple Clusters
  - Replicated Silos: The Simplest Cross-Regional Model
  - Sharding: Regional Data
  - Better Flexibility: Microservice Routing
- Summary
22. Organizing Your Application
- Principles to Guide Us
  - Filesystems as the Source of Truth
  - The Role of Code Review
  - Feature Gates
- Managing Your Application in Source Control
  - Filesystem Layout
  - Managing Periodic Versions
    - Versioning with branches and tags
    - Versioning with directories
- Structuring Your Application for Development, Testing, and Deployment
  - Goals
  - Progression of a Release
    - Introducing a development tag
    - Mapping stages to revisions
- Parameterizing Your Application with Templates
  - Parameterizing with Helm and Templates
  - Filesystem Layout for Parameterization
- Deploying Your Application Around the World
  - Architectures for Worldwide Deployment
  - Implementing Worldwide Deployment
  - Dashboards and Monitoring for Worldwide Deployments
- Summary
A. Building Your Own Kubernetes Cluster
- Parts List
- Flashing Images
- First Boot
  - Setting Up Networking
  - Installing a Container Runtime
  - Installing Kubernetes
  - Setting Up the Cluster
  - Setting Up Cluster Networking
- Summary
Index