Microsoft Certified: Azure Developer Associate (AZ-204) flashcards

A feature that allows an Azure Function App to connect to resources within an Azure Virtual Network privately, ensuring traffic does not traverse the public internet.

• Enables outbound traffic from the Function App into a specified VNet.
• Used for secure access to resources like Azure SQL Database, Azure Storage, or Cosmos DB configured with private endpoints or service endpoints.
• Does not provide inbound access to the Function App from the VNet.

Memory trick: Functions need a VNet key to unlock private data doors.

An Azure Active Directory feature that provides Azure services with an automatically managed identity in Azure AD, allowing them to authenticate to other Azure services without needing to store credentials.

• Eliminates credential management for developers
• Based on Azure AD authentication
• Supports system-assigned and user-assigned identities

Memory trick: Managed Identity: No password, just trust.

A standalone Azure resource that can be assigned to multiple Azure resources to enable them to authenticate to other Azure services without managing credentials.

• Independent lifecycle from the associated resource
• Can be assigned to multiple Azure resources
• Requires explicit creation and assignment

Memory trick: User-assigned: Like a shared key for many doors.

Azure API Management can use a system-assigned or user-assigned managed identity to authenticate to other Azure services that support Azure AD authentication.

• Eliminates the need for API keys or client secrets.
• Leverages Azure AD for authentication and authorization.
• Used in conjunction with `authentication-managed-identity` policy.
• Enhances security by providing a secretless authentication mechanism.

Memory trick: APIM needs its own ID to securely talk to App Services.

Azure App Service Autoscale automatically adjusts the number of running instances for an application based on predefined rules, metrics, or schedules to optimize performance and cost.

• Scales out (adds instances) to handle increased load.
• Scales in (removes instances) to save costs during low load.
• Can be based on CPU, memory, HTTP queue, or custom metrics.
• Supports both scheduled and metric-based rules.

Memory trick: Autoscale: 'A'utomatically 'S'cales 'C'apacity.

A serverless compute service that lets you run event-driven code without provisioning or managing infrastructure.

• Event-driven, scale on demand
• Consumption-based billing (pay-per-execution)
• Supports various programming languages

Memory trick: Functions are serverless, so they run only when needed.

A serverless platform for building and deploying modern apps and microservices using containers.

• Runs containerized microservices
• Supports HTTP and event-driven scaling
• Scales down to zero instances
• Built on Kubernetes and open-source technologies (e.g., Dapr, KEDA)

Memory trick: Container Apps Scale to Zero, Rapidly

In Infrastructure-as-a-Service (IaaS), isolation refers to the logical separation of virtual machines and their resources, ensuring that one VM's activities do not affect others, while still sharing the underlying physical hardware.

• Achieved through hypervisor technology
• Provides dedicated CPU, memory, and storage to each VM
• Network isolation via virtual networks
• Allows for independent OS and application management

Memory trick: VMs give strong isolation, Containers share the host, Functions are just code, App Service is a PaaS host.

A fully managed Kubernetes service for deploying, managing, and scaling containerized applications using the open-source Kubernetes system.

• Simplifies Kubernetes management.
• Ideal for microservices and complex containerized workloads.
• Provides automatic scaling, self-healing, and service discovery.

Memory trick: AKS Keeps Orchestrating Services

Automatically adjusts the number of App Service instances based on metrics (CPU, memory, HTTP queue length) or a predefined schedule.

• Vertical (scale up/down) and Horizontal (scale out/in) options
• Ensures consistent performance during traffic fluctuations
• Optimizes costs by scaling down during low demand

Memory trick: Autoscaling automatically adjusts to demand, saving costs.

The Azure Functions timeout setting defines the maximum duration a function execution can run before it is terminated by the host.

• Default timeout is 5 minutes for Consumption plan.
• Can be configured up to 10 minutes for Consumption plan.
• Premium and Dedicated plans can have longer/unlimited timeouts.
• Important for long-running tasks to prevent premature termination.

Memory trick: Timeout: 'T'erminate 'O'ver 'U'sage 'T'ime.

Azure Batch is a managed service that enables you to run large-scale parallel and high-performance computing (HPC) applications efficiently in Azure.

• Automatically provisions and scales compute nodes (VMs).
• Schedules and runs tasks across the pool of nodes.
• Handles job and task management, including failures.
• Ideal for scientific simulations, rendering, data analysis.

Memory trick: Batch: 'B'ig 'A'utomated 'T'asks 'C'ompleted 'H'ighly efficiently.

A serverless platform optimized for hosting modern microservices and event-driven applications built with containers.

• Fully managed, abstracts Kubernetes
• Supports HTTP and event-driven scaling (KEDA)
• Built-in traffic splitting/routing for revisions
• Ideal for microservices and long-running processes

Memory trick: Container Apps Handle Crazy Event Scaling

For AKS, ReadWriteMany (RWX) access mode allows a volume to be mounted as read-write by many nodes, meaning multiple pods on different nodes can simultaneously read and write to the same persistent volume.

• Azure Files (SMB) supports RWX.
• Crucial for shared data across a cluster.
• Azure Disk Storage only supports ReadWriteOnce (RWO).

Memory trick: AKS Files for Many Shared Reads and Writes.

The maximum duration an Azure Function can execute before being terminated.

• Consumption plan: 5 min default, 10 min max (configurable)
• Premium plan: Unlimited duration (host responsive)
• Dedicated/App Service plan: Default 30 min, configurable up to App Service plan timeout (230s default for HTTP, configurable up to 30min).
• Timeouts vary by hosting plan and trigger type.

Memory trick: Plan Defines Time, Premium is Forever

Azure Files provides fully managed file shares that can be mounted by Azure Kubernetes Service (AKS) pods as shared persistent storage using the Server Message Block (SMB) or Network File System (NFS) protocols.

• Supports ReadWriteMany access mode (multiple pods can write simultaneously)
• Integrates with Kubernetes Persistent Volume Claims (PVCs)
• Highly available and durable
• Can be dynamically provisioned

Memory trick: Files for AKS is like a shared drive, Disks are for single pods, Blob is for objects, Queues for messages alive.

Azure Service Bus dead-lettering is a mechanism to move messages that cannot be delivered or processed successfully to a special 'dead-letter queue' (DLQ).

• Prevents poison messages from blocking the main queue.
• Messages are moved to DLQ after exceeding max delivery attempts or TTL.
• DLQ messages can be inspected, re-submitted, or discarded.
• Ensures application robustness and message flow integrity.

Memory trick: Dead-lettering: 'D'efectives 'L'eave 'Q'ueue.

Azure Container Instances bills based on the actual duration (per second) and resources (CPU, memory) consumed by your container.

• Pay-as-you-go, per second billing
• Charges for CPU and memory allocated
• Ideal for burstable, short-lived, and unpredictable workloads
• No upfront costs or termination fees

Memory trick: ACI bills by the Second, for exactly what you use.

Azure App Service can autoscale based on various metrics, including CPU percentage, memory percentage, HTTP queue length, and custom metrics, to ensure optimal performance and cost efficiency.

• CPU Percentage is a common metric for general processing load.
• Autoscale rules define when to scale out (add instances) and scale in (remove instances).
• Metrics are aggregated (e.g., average, maximum) over a time period.

Memory trick: Metrics 'M'easure 'E'very 'T'hread 'R'unning 'I'n 'C'ode.

Executes an Azure Function on a predetermined, recurring schedule using a cron expression.

• Ideal for scheduled tasks, cleanups, data processing
• Uses NCronTab expressions for defining schedules
• Can be configured to run as frequently as needed (e.g., every second, hour, day)

Memory trick: Timer Triggers run on Time, not on data or requests.

A feature that automatically adjusts the number of instances (scale out/in) for an App Service app based on demand or a schedule.

• Increases/decreases instances automatically
• Based on metrics (e.g., CPU, memory, HTTP queue)
• Ensures performance and cost optimization
• Configurable rules and schedules

Memory trick: Auto Scales for Peak Performance and Cost Savings

A fully managed platform-as-a-service (PaaS) for building, deploying, and scaling web apps, mobile backends, and RESTful APIs, supporting various languages and frameworks, including .NET, Java, Node.js, Python, and PHP.

• Supports Windows and Linux environments
• Built-in auto-scaling and load balancing
• Integrated with Azure DevOps, GitHub, etc. for CI/CD
• Offers various pricing tiers for different needs

Memory trick: App Service runs your site, Functions just do a bit, VMs give full control, AKS orchestrates it.

Azure Container Apps is a serverless container platform that provides capabilities like scale-to-zero, revision management, traffic splitting, and Dapr integration.

• Serverless containers for microservices.
• Scales to zero instances to save costs.
• Built-in revision management and traffic splitting.
• Abstracts Kubernetes infrastructure.

Memory trick: Container Apps: 'C'lever 'A'utomated 'A'dministration for traffic.

Using an Azure Function to react to messages from a Service Bus queue, hosted on a Premium Plan for advanced scaling, VNet access, and extended execution times.

• Service Bus Trigger: Responds to queue/topic messages
• Premium Plan: Pre-warmed instances, VNet access, unlimited runtime
• Automatic scaling based on queue length (via KEDA)
• Ensures reliable processing for complex/long-running tasks

Memory trick: Service Bus Trigger with Premium for Power and Persistence

A service that enables you to run Docker containers on Azure without provisioning any virtual machines or adopting a higher-level orchestration service.

• Fastest way to run a container in Azure
• No VM management required
• Per-second billing
• Suitable for burstable, short-lived workloads

Memory trick: ACI = Quick Container, No VM, Pay Per Second

On-demand, scalable computing resources (virtualized servers) that provide Infrastructure-as-a-Service (IaaS) in Azure.

• Full control over OS and software stack
• IaaS offering
• Can run custom applications and legacy software
• Requires OS patching and management

Memory trick: VMs = Vintage Machines for Maximum Control

On-demand, scalable computing resources that give you full control over the operating system and software stack.

• Infrastructure-as-a-Service (IaaS)
• Full control over OS, software, and configurations
• Requires manual management of OS and patches

Memory trick: VMs give you Very Much control over the OS.

A global, scalable entry-point that uses the Microsoft global edge network to create fast, secure, and widely scalable web applications.

• Global HTTP/HTTPS load balancing (Layer 7)
• Dynamic site acceleration (DSA)
• Web Application Firewall (WAF)
• SSL offloading, end-to-end SSL

Memory trick: Front Door is the First choice for global web apps.

Azure Traffic Manager is a DNS-based traffic load balancer that distributes incoming traffic across multiple global Azure regions to improve application responsiveness and availability.

• DNS-based, operates at the global level.
• Distributes traffic to endpoints in different regions.
• Supports various routing methods (e.g., Performance, Priority, Geographic).
• Ensures high availability and business continuity.

Memory trick: Traffic Manager: 'T'raffic 'M'oves 'G'lobally.

An Azure Function binding that allows a function to be executed in response to an HTTP request, making it suitable for building serverless APIs and webhooks.

• Supports various HTTP methods (GET, POST, PUT, DELETE)
• Can be secured with API keys or Azure Active Directory
• Allows custom routing and URL paths
• Returns HTTP responses directly

Memory trick: Functions build APIs fast, with triggers and bindings that last.

Azure Key Vault provides a secure and centralized store for sensitive data like API keys, connection strings, and certificates that Azure Functions can access at runtime.

• Enhances security by separating secrets from code.
• Provides fine-grained access control (RBAC).
• Supports secret rotation and auditing.

Memory trick: Key Vault 'K'eeps 'K'eys 'K'onfidential.

A property of an Azure Service Bus queue or subscription that specifies the maximum number of times a message can be delivered to a consumer before it is automatically moved to the dead-letter queue.

• Default value is 10
• Configurable per queue/subscription
• Protects against infinite retries for poison messages
• Used in conjunction with message locks and abandon operations

Memory trick: Max Delivery Count saves your messages from infinite loops, sending them to the dead-letter queue like a final scoop.

Groups of nodes within an AKS cluster that share the same configuration, allowing for dedicated compute resources for specific workloads.

• Supports different VM sizes, OS types, and configurations
• Enables workload isolation (e.g., using taints and tolerations)
• Allows for separate scaling and upgrades for different workloads

Memory trick: Node Pools are for Niche workloads on specific Nodes.

ARR Affinity, also known as session affinity or sticky sessions, is an Azure App Service feature that ensures all requests from a specific client are routed to the same backend instance of your web application.

• Crucial for stateful applications (e.g., WebSockets, session data).
• Maintains consistent connections between client and instance.
• Can impact load balancing fairness if not managed carefully.

Memory trick: Always Route Requests to the Right Server.