Azure Application Gateway for Containers (with Gateway API)

Compare containers and virtual machines, focusing on kernel sharing, namespaces, and cgroups. Explain isolation, portability, startup speed, and suitability for microservices.

Explore how microservices decompose a monolithic application into smaller, independently deployable services, enabling flexible scaling, resiliency, and ease of updates using containers.

Explore how Docker, Dockerfile, and Docker Hub enable containerized apps. Build and run images with a Dockerfile and manage containers, while using Docker Hub as a registry.

Create a Python Flask web app, containerize it with a Dockerfile, then build, push to Docker Hub, and run the container on port 80 to test routes and logs.

Explore how Kubernetes manages containerized workloads and how AKS simplifies deployment, scaling, and upgrades with a managed control plane, RBAC, security, and monitoring.

Create and explore an Azure Kubernetes Service (AKS) cluster using the Azure CLI, including resource group setup, node pools, and workload identity for secure access.

Stop and start AKS cluster to save costs; stopping halts the control plane, may change IP, and deprovisions VMs, with only user node pools stoppable via portal or CLI.

Explore core Kubernetes objects such as pods, deployments, and services, and how they enable scalable exposure of container workloads via Gateway API.

Boost kubectl efficiency by enabling autocompletion and aliases like k, persisting settings via bashrc, and reloading profiles; accelerate terminal work in VS Code with Ctrl R and keyboard shortcuts.

Learn quick methods to access AKS nodes by using a privileged helper pod with kubectl debug or kubectl nutshell, and compare their security and speed implications.

Clarify key terminologies around Ingress API and Gateway API in Kubernetes, distinguishing the Ingress API's ingress and ingress class from the gateway resource and other Gateway API resources.

Explore the Kubernetes Ingress API, its routing rules, and how an ingress controller applies them to expose services externally, including ingress class, TLS termination, and YAML basics.

Discover how the Gateway API in Kubernetes enables routing with HTTP, TLS, TCP, UDP, redirects, and traffic splitting. Learn gateway class, controllers, and HTTP routes to manage cross-namespace traffic.

Compare ingress and gateway APIs in Kubernetes, highlighting native ingress, custom gateway resources, cross-namespace routing, advanced routing and porting, with gateway API offering greater flexibility and portability.

Discover Azure application gateway for containers, a layer seven load balancer for Kubernetes that supports ingress and gateway APIs, with host and path routing, SSL termination, and mtls.

Explore deployment strategies for the application gateway for containers, comparing bring your own deployment with the Alb controller managed approach, including front end provisioning, resource lifecycle, and Kubernetes integration.

Compare the application gateway for containers with the application gateway ingress controller, and learn why migrating to agc offers near real-time updates, gateway api support, and mutual tls for backends.

Explore networking considerations for the application gateway for containers, including /24 subnet associations and data plane proxies routing traffic to pods via CNI in Kubernetes.

Deploy two AKS clusters and install the ALB controller with workload identity and OIDC, using Helm, federated credentials, and configure Gateway and Ingress classes and CRDs.

Create and expose an Azure application gateway for containers using a bring your own deployment strategy and gateway API, configuring subnets, front ends, associations, and Kubernetes driven http routes.

Demonstrates creating an application gateway for containers with the managed by controller deployment strategy, provisioning subnet and infrastructure resources, and deploying an Nginx frontend via an application load balancer.

Explore how the application gateway for containers components operate in Azure, including front-end proxies, Gateway API resources with an FQDN, and subnet associations for backend traffic.

Use Azure CLI to query port 8000 for backend health (json) and port 8001 for metrics (text) within the application gateway for containers, with Prometheus integration.

Explain how the application gateway for containers adds three headers—x-forwarded-for, x-forwarded-proto, and x-request-id—to route requests to Kubernetes pods, while the end user never sees them.

Explore vnet peering to connect application gateway for containers and AKS across different vnets using the Azure backbone network, enabling healthy connectivity without public internet access.

Identify why Azure application gateway for containers offers dual ingress and gateway api, native Azure integration, Azure Monitor compatibility, and a separate data plane that preserves cluster resources.

Clarify how we will work through the course, detailing common TLS, domains, and SSL offloading for ingress and gateway APIs, with separate sections and bring-your-own or managed-by-controller clusters.

Create an Azure public DNS zone for your domain, update name servers at Namecheap, and wait for propagation to expose applications via the application gateway for containers.

Learn how to use your own domain with the application gateway for containers by masking front-end fqdns with cname records for scalable multi-application routing.

Demonstrate a Gateway API setup for containers by creating an http route to expose a web app through the application gateway for containers, using path prefix and exact path types.

Configure a custom domain for gateway API by creating a CNAME record that points to the gateway's FQDN, then validate DNS resolution and test access.

Learn to host multiple sites with the Azure Application Gateway for Containers using two frontends, two gateways, and HTTP routes with DNS pointing to each frontend via its FQDN.

Host multiple websites using a single frontend on the gateway api for containers, wiring distinct http routes and hostnames via dns records to the same fqdn.

Configure url and path based routing with the gateway api to direct traffic to separate images and videos services under a single azure application gateway for containers.

Implement header based routing with gateway API to direct traffic to different backend services using environment headers, enabling conditional routing across development, testing, production for Azure application gateway for containers.

Implement query string based routing using the Gateway API by directing HTTP routes to two Kubernetes backends, one without a query and one with a test query parameter.

Implement traffic splitting using weighted round robin with Gateway API, configuring two backends and adjustable weights to control traffic distribution, including 50/50 and 99/1 scenarios.

Set up cross-namespace routing with Gateway API by deploying a gateway in infra, labeling namespaces to control access, and attaching routes across namespaces.

Configure the gateway to allow routes from any namespace. Link it with an application gateway for container frontend and publish http routes across images, videos, and other namespaces.

Enable cross-namespace routing with reference grants in the Gateway API, letting http routes reach services in other namespaces while securing access to secrets and preventing unauthorized references.

Implement a basic ingress api example to expose a containerized app through the application gateway for containers, using ingress rules, annotations, and a cluster ip service.

Expose a web app with a custom domain using the ingress API by masking the gateway frontend with a CNAME in the Azure public DNS zone.

Host multiple sites using a single application gateway for containers frontend with the gateway API, configuring two routing rules for distinct hosts that share the same fqdn.

Implement url-based routing using a single ingress path with two rules on the same host, routing /images to the images SBC and /videos to the videos SBC.

Learn how SSL termination at the application gateway for containers decrypts https traffic and forwards unencrypted requests to backend pods, enabling centralized certificate management and advanced traffic control.

Learn how mutual tls enables authentication in the application gateway for containers, detailing certificates, the certificate authority bundle, and the tls handshake with backend pods.

Learn how to create a self-signed certificate for testing and internal use, generating a 365-day RSA 2048 certificate with a wildcard common name and inspecting its details.

Setup and activate a bought single-domain ssl certificate for the LearnDash Azure domain, generate a csr with OpenSSL, complete domain validation, and download the crt and bundle files.

Obtain a free wildcard TLS certificate from Let's Encrypt by manually using certbot with the DNS-01 challenge, including adding a DNS TXT record and reviewing pem files.

Implement ssl termination at the application gateway for containers, decrypting https and sending http to backend pods; use a Let's Encrypt secret and a tls terminated gateway on port 443.

Learn to set up mTLS in the application gateway for containers with Gateway API, configuring front-end and back-end TLS using secrets, certificates, and a back-end policy for secure 443/8443 traffic.

Configure the gateway resource to specify multiple tls secrets and expose different apps, such as nginx and httpd, on port 443 with distinct hostnames.

Explore the Gateway API's role oriented security model, mapping infrastructure provider, cluster operator, and application developers to gateway class, gateway, and routes, with role-based access control governing access.

Prepare the AKs cluster environment for Kubernetes RBAC in the Gateway API by integrating Azure Active Directory and defining admin, cluster operator, and application developer roles.

Enable Azure AD authentication with Kubernetes RBAC in AKS to secure Gateway API access, and configure admin, cluster operator, and application developer roles with a gateway deployment.

Set up ssl termination for containers with the Ingress API by deploying nginx, creating a tls secret from a self-signed certificate, and configuring host, path, and tls rules.

Learn to troubleshoot application gateway for containers by checking controller logs and validating Gateway API resources. Identify issues in http routes and backend health, and simulate misconfigurations to confirm fixes.

Explore activity logs for Azure resources to see who did and when, including create, update, and delete actions, and use Azure Monitor to build alerts and export logs for auditing.

Diagnose and solve problems in Azure application gateway for containers via a centralized resource health dashboard offering actionable telemetry-based recommendations, troubleshooters, and automatic best practices to fix misconfigurations and bottlenecks.

Explore Metrics Explorer in Azure Monitor to build dashboards and alerts for the application gateway for containers, monitor total requests, HTTP status, and backend health over time.