Cloud Native Infrastructure with Azure - Helion
ebook
Autor: Nishant Singh, Michael KehoeISBN: 9781492090915
stron: 324, Format: ebook
Data wydania: 2022-02-09
Księgarnia: Helion
Cena książki: 194,65 zł (poprzednio: 226,34 zł)
Oszczędzasz: 14% (-31,69 zł)
The cloud is becoming the de facto home for companies ranging from enterprises to startups. Moving to the cloud means moving your applications from monolith to microservices. But once you do, running and maintaining these services brings its own level of complexity. The answer? Modularity, deployability, observability, and self-healing capacity through cloud native development.
With this practical book, Nishant Singh and Michael Kehoe show you how to build a true cloud native infrastructure using Microsoft Azure or another cloud computing solution by following guidelines from the Cloud Native Computing Foundation (CNCF). DevOps and site reliability engineers will learn how adapting applications to cloud native early in the design phase helps you fully utilize the elasticity and distributed nature of the cloud.
This book helps you explore:
- Why go cloud native?
- How to use infrastructure as code
- What it takes to containerize an application
- Why and how Kubernetes is the "grand orchestrator"
- How to create a Kubernetes cluster on Azure
- How observability complements monitoring
- How to use service discovery and a service mesh to find new territories
- How networking and policy management serve as gatekeepers
- How distributed databases and storage work
Osoby które kupowały "Cloud Native Infrastructure with Azure", wybierały także:
- Windows Media Center. Domowe centrum rozrywki 66,67 zł, (8,00 zł -88%)
- Ruby on Rails. Ćwiczenia 18,75 zł, (3,00 zł -84%)
- DevOps w praktyce. Kurs video. Jenkins, Ansible, Terraform i Docker 190,00 zł, (39,90 zł -79%)
- Przywództwo w świecie VUCA. Jak być skutecznym liderem w niepewnym środowisku 58,64 zł, (12,90 zł -78%)
- Scrum. O zwinnym zarządzaniu projektami. Wydanie II rozszerzone 58,64 zł, (12,90 zł -78%)
Spis treści
Cloud Native Infrastructure with Azure eBook -- spis treści
- Preface
- Who Should Read This Book
- Goals of This Book
- Navigating This Book
- Conventions Used in This Book
- Using Code Examples
- OReilly Online Learning
- How to Contact Us
- Acknowledgments
- 1. Introduction: Why Cloud Native?
- The Journey to the Cloud
- Challenges in the Cloud
- Cloud Native Computing Foundation
- Adopting a Cloud Native Infrastructure with Azure
- Summary
- 2. Infrastructure as Code: Setting Up the Gateway
- Infrastructure as Code and Its Importance in the Cloud Native World
- Getting Started with Azure and Setting Up the Environment
- Azure Fundamentals and Preparing Your Azure Environment
- Creating an Azure Account
- Installing the Azure CLI
- Prominent IaC Tools
- Terraform
- Installing Terraform
- Setting up Terraform access to a Microsoft Azure account
- Basic usage and infrastructure setup with Terraform
- Exploring the Azure infrastructure with Terraform
- Creating Azure blob storage
- Creating an Azure virtual network and instances.
- Terraform and ARM templates
- Packer
- Installing Packer
- Building a Linux image on Azure
- Ansible
- Terraform
- Azure DevOps and Infrastructure as Code
- Summary
- 3. Containerizing Your Application: More Than Boxes
- Why Containers?
- Isolation
- Security
- Packaging and Deployment
- Basic Container Primitives
- Cgroups
- Namespaces
- Copy on Write
- Capabilities
- Seccomp-BPF
- Components of Running a Container
- Container Orchestrators
- Container Software
- Container Runtimes
- Containerd
- CRI-O
- Docker
- Containers
- Operating System
- Open Container Initiative (OCI) Specification
- OCI Image Specification
- OCI Runtime Specification
- Docker
- Building Your First Docker Image
- Best Practices While Using Docker
- Other Container Platforms
- Kata Containers
- LXC and LXD
- Container Registries
- Securely Storing Images with Harbor
- Installing Harbor
- Configuring Harbor for installation
- Building a Packer image
- Securely Storing Images with Azure Container Registry
- Installing Azure Container Registry
- Securely Storing Images with Harbor
- Storing Docker Images in a Registry
- Running Docker on Azure
- Azure Container Instances
- Deploying an Azure Container Instance
- Running a Docker Container Engine
- Summary
- Why Containers?
- 4. Kubernetes: The Grand Orchestrator
- Kubernetes Components
- Control Plane
- kube-apiserver (API server)
- Kube scheduler
- Kube controller manager
- etcd
- Worker Nodes
- Kubelet
- Kube-proxy
- Control Plane
- Kubernetes API Server Objects
- Pods
- ReplicaSets
- Deployments
- Services
- Namespaces
- Labels and Selectors
- Annotations
- Ingress Controller
- StatefulSets
- DaemonSets
- Jobs
- Observe, Operate, and Manage Kubernetes Clusters with kubectl
- General Cluster Information and Commands
- Managing Pods
- Health checks
- Liveness probe
- Readiness probe
- Startup probe
- Resource limits
- Volumes
- Persistent Volume Claim (PVC)
- Persistent volumestatic
- Storage classdynamic
- Health checks
- Kubernetes in Production
- ReplicaSets
- Deployments
- Horizontal Pod Autoscaler
- Service
- Ingress
- DaemonSet
- Jobs
- Summary
- Kubernetes Components
- 5. Creating a Kubernetes Cluster in Azure
- Creating a Kubernetes Cluster from Scratch
- Creating the Resource Group
- Creating the Machine Images for the Worker and Controller Machines
- Creating a Storage Account Backend
- Creating an Azure Virtual Network
- Creating Public IPs for the Load Balancer
- Creating Worker and Controller Instances
- Using Ansible to Deploy and Configure the Kubernetes Controller Nodes
- Using Ansible to Deploy and Configure the Kubernetes Worker Nodes
- Setting Up Pod Networking and Routing
- Generating the kubeconfig File for Remote Access and Cluster Validation
- Azure Kubernetes Service
- Deploying Applications and Services Using Helm: A Package Manager for Kubernetes
- Helm Basics
- Installing and Managing Helm
- Searching Helm repositories
- Installing a Helm chart on Kubernetes
- Changing default chart values
- Managing Helm Releases
- Checking a release
- Upgrading a release
- Rolling back a release
- Uninstalling a release
- Creating Charts for Your Applications
- Using Helm to create and manage charts
- Summary
- Creating a Kubernetes Cluster from Scratch
- 6. Observability: Following the Breadcrumbs
- Introduction to Observability
- Observability: More Than Three Pillars
- Metrics
- Logs
- Traces
- Observability: A Superset of Monitoring
- Observability-Driven Development
- Observability: More Than Three Pillars
- Monitoring Metrics with Prometheus in a Cloud Native World
- Prometheus Components and Architecture
- Installing and Configuring Prometheus
- node_exporter
- Instrumentation of Applications
- Counters
- Gauges
- Summary
- Histograms
- Finding Hosts
- Using Ansible
- Using Files
- Using azure_sd_config
- Prometheus on Kubernetes
- The node role
- The service role
- The Pod role
- The endpoints role
- The ingress role
- Logging in the Cloud Native World
- Logging with Fluentd
- source directive (where all the data is ingested)
- match directive (what to do with the input data)
- filter directive (the event processing pipeline)
- system directive (sets system-wide configuration)
- label directive (for output grouping and routing)
- @include directive (to import config files)
- Fluentd on Kubernetes
- Sidecar container approach
- Node-level logging agent approach
- Logging with Fluentd
- Distributed Tracing in the Cloud Native World
- Tracing: Key Concepts
- Spans
- Traces
- Context propagation
- Sampling
- General Tracing System Architecture and Trace Assembly
- Tracing Standards, Tools, and Code Instrumentation
- Tracing: Key Concepts
- Azure Monitor
- Summary
- Introduction to Observability
- 7. Service Discovery and Service Mesh: Finding New Territories and Crossing Borders
- Service Discovery
- Introduction to CoreDNS
- Installing and Configuring CoreDNS
- Kubernetes Service Discovery with CoreDNS
- Azure DNS
- The Service Mesh
- Introduction to Istio
- Installing Istio on Azure Kubernetes Service
- Installing Istio using Helm
- Automatically Injecting the Sidecar Proxy (Envoy Proxy)
- Managing Istio Service Meshes Using Kiali
- Exploring the Kiali dashboard
- Summary
- Service Discovery
- 8. Networking and Policy Management: Behold the Gatekeepers
- The Container Network Interface (CNI)
- Why Would You Use a CNI?
- How Does CNI Work with Azure?
- Various CNI Projects
- Calico
- Why Would You Use Calico?
- Basic Architecture
- Deploying Calico
- Deploying Calico via AKS installation
- Installing Calico manually
- Installing calicoctl
- A Calico Deep Dive
- Enabling eBPF
- Implementing Calico Security Policy
- GlobalNetworkPolicy: Allowing ICMP traffic
- NetworkPolicy: Allowing traffic within a namespace between two labels
- Cilium
- Deploying Cilium
- Self-managed Cilium installation
- AKS Cilium installation
- Installing Hubble
- Integrating Cilium with Your Cloud
- Host firewall
- Observability
- Deploying Cilium
- Flannel
- Deploying Flannel
- A Flannel Deep Dive
- Azure Policy
- Azure Policy Quickstart
- Creating Your Own Azure Policy
- Azure Policy for Kubernetes
- Open Policy Agent
- Deploying OPA on Kubernetes
- Deploying Policy with OPA
- Summary
- The Container Network Interface (CNI)
- 9. Distributed Databases and Storage: The Central Bank
- The Need for Distributed Databases in Cloud Native Architecture
- Azure Storage and Database Options
- Introduction to Vitess: Distributed and Sharded MySQL
- Why Run Vitess?
- The Vitess Architecture
- Deploying Vitess on Kubernetes
- Introduction to Rook: Storage Orchestrator for Kubernetes
- The Rook Architecture
- Deploying Rook on Kubernetes
- Introduction to TiKV
- Why Use TiKV?
- The TiKV Architecture
- Deploying TiKV on Kubernetes
- More on etcd
- Hardware Platform
- Autoscaling and Auto-remediation
- Availability and Security
- etcd TLS
- Role-based access control
- Summary
- The Need for Distributed Databases in Cloud Native Architecture
- 10. Getting the Message
- The Need for Messaging
- A Sample Messaging Use Case: Log Ingestion and Analytics
- Generation 1: Without Queues
- Generation 2: With Cloud Queues and Object Storage
- Generation 3: With Memory-Based Pub/Sub Queuing
- The Basics of Messaging Platforms
- Messaging Versus Streaming
- Messaging Fundamentals
- Producers and Consumers
- Brokers and Clustering
- Durability and Persistence
- Message Delivery
- Security
- Common Messaging Patterns
- Simple Queue
- Publish and Subscribe
- Durable Queue
- An Overview of Popular Cloud Native Messaging Platforms
- RabbitMQ
- Apache Kafka
- CNCF CloudEvents
- Cloud Messaging Deep Dive with NATS
- NATS Protocol Architecture
- Clustering multiple NATS servers
- Using the Docker NATS server
- Monitoring NATS servers
- NATS Persistence with JetStream
- NATS Security
- Nkey-based authentication
- TLS authentication
- Deploying NATS on Kubernetes
- NATS Protocol Architecture
- Azure Messaging Services
- Azure Service Bus
- Service Bus concepts
- Namespaces
- Queues, topics, and subscriptions
- Managing Azure Service Bus with Terraform
- Sending and receiving messages to a Service Bus queue in Python
- Service Bus concepts
- Azure Event Hubs
- Managing Azure Event Hubs with Terraform
- Azure Event Grid
- Deploying and using event grids
- Azure Service Bus
- Summary
- 11. Serverless
- Introduction to Serverless Computing
- What Is Serverless?
- What Is a Serverless Function?
- The Serverless Landscape
- Benefits of Serverless
- Potential Downsides of Serverless
- Azure Function Apps
- Function App Architecture
- Creating a Function App
- Knative
- Knative Architecture
- Installing and Running Knative Serving on Kubernetes
- Installing and Running Knative Eventing on Kubernetes
- KEDA
- KEDA Architecture
- Installing KEDA on Kubernetes
- OpenFaaS
- OpenFaaS Architecture
- Installing OpenFaaS
- Writing Your First OpenFaaS Function
- Summary
- Introduction to Serverless Computing
- 12. Conclusion
- Whats Next?
- Index