Hands-On Linux for Architects电子书

About Packt

Why subscribe?

Packt.com

Contributors

About the authors

About the reviewer

Packt is searching for authors like you

Dedication

Preface

Who this book is for

What this book covers

To get the most out of this book

Download the example code files

Download the color images

Conventions used

Get in touch

Reviews

Section 1: High-Performance Storage Solutions with GlusterFS

Introduction to Design Methodology

Defining the stages of solution design and why they matter

Analyzing the problem and asking the right questions

Technical standpoint

Business standpoint

Functional standpoint

Considering possible solutions

POC

Implementing the solution

Summary

Questions

Further reading

Defining GlusterFS Storage

Technical requirements

What is a cluster?

Computing a cluster

Storage clusters

What is GlusterFS?

SDS

Cost reduction

Scalability

Control

The market is moving toward SDS

Massive storage

Block, file, and object storage

Block storage

File storage

Object storage

Why choose GlusterFS?

GlusterFS features

Commodity hardware – GlusterFS runs on pretty much anything

GlusterFS can be deployed on private, public, or hybrid clouds

No single point of failure

Scalability

Asynchronous geo-replication

Performance

Self-healing

Flexibility

Remote direct memory access (RDMA)

Gluster volume types

Distributed

Replicated

Distributed replicated

Dispersed

Distributed dispersed

The need for highly redundant storage

Disaster recovery

RTO

RPO

Synchronous replication

Asynchronous replication

The need for high performance

Parallel I/O

Summary

Questions

Further reading

Architecting a Storage Cluster

Technical requirements

GlusterFS compute requirements

RAM

Why is cache important?

CPU

Cloud considerations

How much space do you need?

GlusterFS volume type

Distributed

Replicated

Dispersed

Space required by the application

Projected growth

Performance considerations

Throughput

Latency

IOPS

I/O size

GlusterFS performance

Volume type

Brick layout

Number of nodes

Tuning parameters

The best approach for high availability

Replicated

Dispersed

Geo-replication

How the workload defines requirements

Documentation

System tools

File type and size

Ask the right questions

Summary

Questions

Further reading

Using GlusterFS on the Cloud Infrastructure

Technical requirements

Setting up the bricks used for backend storage

Azure deployment

ZFS as the backend for the bricks

Installing ZFS

Configuring the zpools

Adding the ZFS cache to the pool (optional)

Installing GlusterFS on the nodes

Installing the packages

Creating the trusted pool

Creating the volumes

Creating a dispersed volume

Mounting the volume

Optimizing performance

GlusterFS tuning

ZFS

ARC

L2ARC

Summary

Questions

Further reading

Analyzing Performance in a Gluster System

Technical requirements

An overview of the implementation

An overview of the cluster

Performance testing

Performance theory

Performance tools

The ZFS zpool iostat command

iostat

The FIO tester

Availability testing

Scaling

Summary

Questions

Further reading

Section 2: High-Availablility Nginx Web Application Using Kubernetes

Creating a Highly Available Self-Healing Architecture

Microservices

Creating container images

FROM

LABEL

RUN

ENV

COPY

EXPOSE

CMD and ENTRYPOINT

Building container images using best practices

Container orchestration

Kubernetes

Summary

Questions

Further reading

Bibliography/sources

Understanding the Core Components of a Kubernetes Cluster

The Kubernetes control plane

The kube-apiserver

The kube-controller-manager

The kube-scheduler

The etcd database

Kubernetes worker nodes

Container runtime

The kubelet

The kube-proxy

Kubernetes objects

Pods – the basis of Kubernetes

Deployments

Services

Kubernetes and persistent storage

Volumes

Persistent Volumes, Persistent Volume Claims, and Storage Classes

Summary

Questions

Further reading

Architecting a Kubernetes Cluster

Kube-sizing

etcd considerations

kube-apiserver sizing

Worker nodes

Load balancer considerations

Storage considerations

Network requirements

Kubernetes DNS-based service discovery

Customizing kube objects

Namespacing

Limiting namespace resources

Customizing pods

Summary

Questions

Further reading

Deploying and Configuring Kubernetes

Infrastructure deployment

Installing Azure CLI

Configuring Azure CLI

High-level design overview

Provisioning network resources

Provisioning compute resources

Preparing the management VM

Generating certificates

Certificate authority

Client certificates

Control plane certificates

Sending our certificates home

Kubeconfigs

Installing kubectl

Control plane kubeconfigs

Kube-controller-manager

Kube-scheduler

Kubelet configs

Kube-proxy

Moving configs around

Installing the control plane

ETCD

Installing etcd

Encrypting etcd data

Installing the Kubernetes controller binaries

Kube-apiserver

Kube-controller-manager

Kube-scheduler

Starting the control plane

Setting RBAC permissions for kubelets.

Cluster role

Cluster role binding

Load-balancer setup

Creating the load-balancer

Azure load-balancer

The backend pool

Health probes

Load-balancing rules

Worker node setup

Downloading and preparing binaries

Adding the Kubernetes repository

Installing dependencies and kubectl

Downloading and storing worker binaries

Containerd setup

The kubelet

kube-proxy

Starting services

Kubernetes networking

Getting the nodes ready

Configuring remote access

Installing Weave Net

DNS server

Managing Kubernetes on the cloud

Summary

Questions

Further reading

Bibliography/sources:

Section 3: Elastic Stack

Monitoring with the ELK Stack

Technical requirements

Understanding the need for monitoring

Decisions made through historical data

Proactively detect problems

Understand environment performance

Plan for budget

Centralized logs

Elasticsearch overview

Fast

Scalable

Highly available

Logstash

Grok

Custom patterns

Kibana brings everything together

Summary

Questions

Further reading

Designing an ELK Stack

Technical requirements

Elasticsearch CPU requirements

CPU count

CPU speed

CPU performance impact

Startup

Index per second

Search latency

Recommendations

Test/dev

Production

Memory sizing for Elasticsearch

Filesystem cache

Disable swap

Undersizing memory

Unable start

OOM killer

Recommendations

Storage configuration for Elasticsearch

Capacity

Performance

Considerations

Logstash and Kibana requirements

Logstash

Kibana

Summary

Questions

Further reading

Using Elasticsearch, Logstash, and Kibana to Manage Logs

Technical requirements

Deployment overview

Installing Elasticsearch

The RPM repository

The Elasticsearch data directory

Partitioning the disk

Formatting the filesystem

Persistent mounting using fstab

Configuring Elasticsearch

Elasticsearch YAML

Cluster name

Discovery settings

Node name

Network host

Path settings

Starting Elasticsearch

Adding an Elasticsearch node

Installing Logstash and Kibana

Configuring Logstash

Logstash YAML

Logstash pipelines

Configuring Kibana

Kibana YAML

The coordinating node

Starting Logstash and Kibana

What are Beats?

Filebeat

Metricbeat

Let's not skip a beat – installing Beats

Configuring Beats clients

Filebeat YAML

Metricbeat YAML

Next steps

Summary

Questions

Further reading

Section 4: System Management Using Saltstack

Solving Management Problems with Salty Solutions

Centralizing system management

New technologies and system management

Recovering control of our own infrastructure

Centralized tools to disperse problems

Coding for a desired state

Understanding NaCl

Introducing Salt

The SaltStack platform

Salt capabilities

Remote command execution modules

The sys module

The pkg module

The test module

Salt states

Grains of Salt

Salt pillars

Summary

Questions

Further reading

Getting Your Hands Salty

Hands-on with Salt

Scenario

Terraforming our initial infrastructure

Setting up Terraform

Creating IaC

Installing Salt with package managers

Installing CentOS yum

Ubuntu apt-getting Salt

Installing Salt via the bootstrap script

Master and minion handshake

Working with Salt

Creating WebServer formulas

Creating load-balancing formulas

Summary

Design Best Practices

Designing for the occasion

On-premises environments

Bare metal server

Virtual machines

Cloud environments

The journey to the cloud

Assessing

Migrating

Lift and shift

Refactor

Rearchitecting

Rebuild

Optimizing

DevOps

Monolithic waterfalls

Agile solutions to monolithic problems

Continuous culture for CI/CD

Summary

Questions

Further reading

Assessments

Chapter 1: Introduction to Design Methodology

Chapter 2: Defining GlusterFS Storage

Chapter 3: Architecting a Storage Cluster

Chapter 4: Using GlusterFS on Cloud Infrastructure

Chapter 5: Analyzing Performance in a Gluster System

Chapter 6: Creating a Highly Available Self-Healing Architecture

Chapter 7: Understanding the Core Components of a Kubernetes Cluster

Chapter 8: Architecting Kubernetes on Azure

Chapter 9: Deploying and Configuring Kubernetes

Chapter 10: Monitoring with ELK stack

Chapter 11: Designing an ELK Stack

Chapter 12: Using Elasticsearch, Logstash, and Kibana to Manage Logs

Chapter 13: Solving Management Problems with Salty Solutions

Chapter 14: Designing a Salt Solution and Installing the Software

Chapter 15: Design Best Practices

Other Books You May Enjoy

Leave a review - let other readers know what you think