Implementing Azure: Putting Modern DevOps to Use电子书

Title Page

Copyright and Credits

Implementing Azure: Putting Modern DevOps to Use

About Packt

Why subscribe?

Packt.com

Contributors

About the authors

Packt is searching for authors like you

Preface

Who this book is for

What this book covers

To get the most out of this book

Download the example code files

Conventions used

Get in touch

Reviews

Getting Started with Azure Implementation

Technical requirements

Service models

Deployment models

Cloud characteristics

Multi-cloud characteristics and models

Cloud brokering

Best of breed

Microsoft Azure

Azure services overview

Azure basics

Azure Resource Manager (ARM)

Resources

Azure regions

Microsoft data center and backbone

Azure portal

Azure automation

Azure automation tools

REST APIs

Summary

Azure Resource Manager and Tools

Technical requirements

Understanding ARM

Functionalities provided by ARM

Working with ARM

Creating an Azure resource group

Adding a resource to a resource group

First approach – adding a storage account to your resource group

Second approach – adding a storage account to your resource group

Tagging in ARM

Locking Azure resources

Azure resource locks

Working with ARM templates

Exporting a deployment as an ARM template (for IT pros)

Example 1 – exporting a resource group to an ARM template

Example 2 – exporting a resource (classic) to an ARM template

Modifying an ARM template

Authoring an ARM template

Creating your own ARM template (for developers)

Summary

Deploying and Synchronizing Azure Active Directory

Azure AD

Azure AD options

Azure AD free

Azure AD basic

Azure AD premium P1

Deploying a custom Azure AD

Adding accounts and groups to Azure AD

Installing Azure AD Connect – prerequisites

Installing a basic Azure AD Connect environment

Azure AD Connect highly available infrastructure

Azure AD conditional access

Azure AD DS

Summary

Implementing Azure Networks

Azure networking limits

Azure networking components

Azure virtual networks (VNet)

VNet peering and global VNet peering

VNet service endpoints

Azure VPN gateways

Azure local gateway

Azure virtual WAN

Azure ExpressRoute

Route filter

ExpressRoute Direct

ExpressRoute Global Reach

Azure connections

Azure route

Azure Firewall

Azure third-party network devices

Azure load balancer

Hash-based distribution

Port forwarding

Automatic reconfiguration

Service monitoring

Source NAT

Azure Application Gateways and Web Application Firewall

Web Application Firewall

Azure Traffic Manager

Azure DNS

Azure DDoS

Setting up Azure networks

Setting up Azure VNet

Setting up Azure virtual network site-to-site VPN

Configuring local network gateway

Configuring Azure virtual network gateway

Configuring connection between local and virtual network gateways

Setting up Azure virtual network with MPLS and ExpressRoute

Configuring Azure virtual network gateway

Configuring Azure ExpressRoute circuit

Setting up Azure VNet peering

Preparing the deployment

Configuring VNet peering

Configuring custom routes

Common Azure network architectures

Summary

Implementing Azure Storage

Storage accounts

The Blob storage account

General-purpose storage v1 account

General-purpose storage v2 accounts

Azure File Sync/Storage Sync services

Azure Data Lake

Replication and redundancy

Locally redundant storage (LRS)

Zone-redundant storage (ZRS)

Geo-redundant storage (GRS)

Read-access geo-redundant storage (RA-GRS)

Azure Storage services

Blob storage services

Table storage services

Queue storage services

File storage services

Access keys

Exploring Azure Storage with Azure Storage Explorer

Premium storage accounts

Premium storage requirements

Pricing

How to deploy a storage account?

Summary

Implementing Azure-Managed Kubernetes and Azure Container Service

Technical requirements

Containers – the concept and basics

Microservices – the concept

Workloads to run in containers

Deploying container hosts in Azure

Docker on Linux

Windows Server Container VM

Azure Container Registry (ACR)

ACI

Creating a first container in Azure

Azure Marketplace containers

Creating custom containers

Container orchestration

The concept of container orchestration

Azure Kubernetes Service (AKS)

Summary

Azure Hybrid Data Center Services

Technical requirements

ASDK

Preparing the ASDK host

Identity management configuration

Networking configuration

VM design of Azure Stack (ASDK)

Azure Stack configuration task

Operating Azure Stack

Working with the portals

Working with PowerShell

Working with the CLI

Hybrid cloud patterns

Configure hybrid cloud connectivity

Machine learning solution with Azure Stack

Azure stack staged data analysis

Azure Stack cloud burst scenario

Azure Stack geo-distributed Application

Monitoring Azure Stack

Summary

Azure Web Apps Basics

Introduction to Azure App Service

Azure Web Apps

App Service plans

Azure App Service Environments

App Service Environment types

Creating an App Service Environment

Creating an App Service plan

Creating an App Service

Summary

Managing Azure Web Apps

Deployment slots

Deployment slots key points

App Service application settings

Application settings key points

Azure App Service scalability

Scaling up

App Service plan scaleup key points

Scaling out

Scaling out the App Service plan manually

Scaling out the App Service plan automatically

Key points for autoscaling your App Service plan

Azure App Service backup

App Service backup key points

Summary

Basics of Azure SQL Database

Introduction to Azure SQL Database

Why Azure SQL Database?

SQL Database (IaaS/PaaS)

Azure SQL Database (PaaS)

Scenarios that would fit Azure SQL Database

SQL on Azure VMs (IaaS)

Scenarios that would suit SQL on Azure VMs

Azure SQL Database types

Elastic database pools

Single databases

SQL database managed instance

Service tier types

DTU service tiers

vCore service tiers

Creating an Azure SQL Database

Connecting to Azure SQL Database

Server-level firewall

Connecting to Azure SQL Database using SQL SSMS

Summary

Managing Azure SQL Database

Azure SQL elastic database pools

Benefits of using elastic database pools

Creating an elastic database pool

Adding a database to an elastic pool

Setting Azure Active Directory authentication

Azure SQL Database business continuity

How business continuity works in Azure SQL Database

Hardware failure

Point-in-time restore

Point-in-time restoration key points

Restoring a deleted database

Active geo-replication

Auto-failover groups

Azure SQL Managed Instances

Azure SQL Managed Instance types

Creating an Azure SQL Managed Instance

Connecting to an Azure SQL Managed Instance

Azure SQL Managed Instance key points

Summary

Microservices 2013; Getting to Know the Buzzword

What are Microservices?

Microservices hosting platform

The Microservice advantage

Fault tolerance

Technology-agnostic

Development agility

Heterogeneous deployment

Manageability

Reusability

The SOA principle

Issues with SOA

The Microservices solution

Inter-Microservice communication

Communication through user interface

Sharing common code

Composite user interface for the web

Thin backend for rich clients

Synchronous communication

Asynchronous communication

Orchestrated communication

Shared data

Architecture of Microservices-based systems

Conway's law

Summary

Understanding Azure Service Fabric

The Service Fabric advantage

Highly scalable

Support for partitioning

Rolling updates

State redundancy

High-density deployment

Automatic fault tolerance

Heterogeneous hosting platforms

Technology agnostic

Centralized management

Service Fabric as an orchestrator

Orchestration as a Service

Is a cluster resource manager similar to an Azure load balancer?

Architecture of cluster resource manager

Architecture of Service Fabric

Transport Subsystem

Federation Subsystem

Reliability Subsystem

Management Subsystem

Hosting subsystem

Communication subsystem

Testability Subsystem

Deconstructing Service Fabric

Infrastructure model

Cluster

Node

System services

Naming service

Image store service

Upgrade service

Failover manager service

Cluster manager service

Service placement

Application model

Programming model

Guest Executables

Reliable Services

Reliable Actors

Creating a cluster on Azure

Basics

Cluster configuration

Security

Summary

Viewing your cluster status

Service Fabric Explorer

Summary view

Cluster Map

Fault domains

Upgrade domains

Viewing applications and services

Cluster nodes

Actions

System

Preparing your system

Summary

Hands-on with Service Fabric – Guest Executables

Service Fabric discovery and communication

Service protocols

Service discovery

Connections from applications external to Service Fabric

Configuring ports and protocols

Configuring the service manifest

Configuring the custom endpoint

Configuring the Azure load balancer

Configuring the health check

Built-in communication API

Deploying a Guest Executable

Understanding the manifests

Package structure

Packaging Guest Executables using Visual Studio

Manually packaging a Guest Executable

Creating the directory structure

Adding code and configuration

Updating service manifest

Updating the application manifest

Deployment

Deploying a Guest Container

Deploying Windows Container

Container image deployment and activation

Resource governance

Container port to host port mapping

Container-to-container discovery and communication

Configuring and setting environment variables

Deploying a Linux container

Summary

Hands on with Service Fabric – Reliable Services

Exploring the Service Fabric Explorer

Application Type

Application instance

Service type

Partition

Replica

Stateless Reliable Services

Stateless service architecture

Stateless service lifecycle

Scaling stateless services

Stateless frontend and stateless middle-tier

Stateless frontend and stateful middle-tier

Reliable Services communication

Exploring the application model

Stateful service

Stateful service architecture

Reliable Collections

Up and down counter application

Stateful service lifecycle

Service partitioning

Service replicas

Summary

Reliable Actors

Actor model

What is an Actor?

Actors in Service Fabric

Actor lifetime

Saving state

Distribution and failover

Actor communication

The Actor proxy

Concurrency

Reentrancy

Asynchronous drivers

Timers

Actor reminders

Actor events

Your first Reliable Actors application

Summary

Microservices Architecture Patterns Motivation

Creating an architecture

Defining the solution boundaries

Creating the solution structure

Component design

Classification of architectural patterns

Optimization or non-functional patterns

Operational patterns

Implementation or functional patterns

Picking up the right architecture pattern

Context

Forces

Complementing patterns

Applying a pattern

Structural variation

Behavioral variation

Internal variation

Domain dependent variation

Summary

Microservices Architectural Patterns

Architectural patterns

Service proxy

Problem

Solution

Considerations

Related patterns

Use cases

Service Façade \ API Gateway

Problem

Solution

Considerations

Related patterns

Use cases

Reliable Data Store

Problem

Solution

Considerations

Related patterns

Use cases

Cluster Orchestrator

Problem

Solution

Considerations

Related patterns

Use cases

Auto-scaling

Problem

Solution

Considerations

Related patterns

Use cases

Partitioning

Problem

Solution

Considerations

Related patterns

Use cases

Centralized Diagnostics Service

Problem

Solution

Considerations

Related patterns

Use cases

High Density Deployment

Problem

Solution

Considerations

Related patterns

Use cases

API Gateway

Problem

Solution

Considerations

Related patterns

Use cases

Latency Optimized Load Balancing

Problem

Solution

Considerations

Related patterns

Use cases

Queue Driven Decomposing Strategy

Problem

Solution

Considerations

Related patterns

Use cases

Circuit Breaker

Problem

Solution

Considerations

Related patterns

Use cases

Message Broker for Communication

Problem

Solution

Considerations

Related patterns

Use cases

Compensating Transaction

Problem

Solution

Considerations

Related patterns

Use cases

Rate Limiter

Problem

Solution

Considerations

Related patterns

Use cases

Sagas

Problem

Solution

Considerations

Related patterns

Use cases

Master Data Management

Problem

Solution

Considerations

Related patterns

Use cases

CQRS – Command Query Responsibility Segregation

Problem

Solution

Microservices in CQRS

Advantages

Considerations

Related patterns

Use cases

Event Sourcing

Problem

Solution

Considerations

Related patterns

Use cases

Remindable Actors

Problem

Solution

Considerations

Related patterns

Use cases

Managed Actors

Problem

Solution

Considerations

Related patterns

Use cases

Summary

Securing and Managing Your Microservices

Securing the communication channels

Inter-node communication

Client to node security

Certificate security

Azure Active Directory security

Publishing an application to a secured cluster

Managing Service Fabric clusters with Windows PowerShell

Prerequisites

Deploying Service Fabric applications

Upgrading Service Fabric applications

Removing Service Fabric applications

Summary

Diagnostics and Monitoring

Health entities

Health state

Health policies

Cluster health policy

Application health policy

Service type health policy

Health evaluation

Health reporting

Centralized logging

Collecting logs

Diagnostic extension

Deploying the Diagnostics extension

Summary

Continuous Integration and Continuous Deployment

Continuous Integration

Continuous Delivery

Deploying Service Fabric application on a standalone cluster

Deploying the application

Summary

Serverless Microservices

Before committing to Nanoservices

Building Nanoservices with Azure Functions

Function app templates

Timer function apps

Data processing function apps

Webhook and API function apps

Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think