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

Customer-managed keys (CMK) allow you to use your own encryption keys from Azure Key Vault to encrypt data at rest in Azure Storage, providing greater control over your encryption keys.

• Keys are stored and managed in Azure Key Vault.
• Provides enhanced control over encryption key lifecycle.
• Applies to data at rest encryption for Azure Blob, File, Table, and Queue storage.

Memory trick: Customer's Keys (CMK) give Control.

A feature of Azure Blob Storage that automatically saves the previous state of a blob each time it's modified or deleted, allowing recovery of earlier versions.

• Creates new versions on write or delete.
• Enables point-in-time recovery.
• Supports compliance auditing.
• Increases storage costs due to multiple versions.

Memory trick: Versioning is like a 'Time Machine' for your blobs, letting you go back to any version.

A fully managed file share service in the cloud, accessible via SMB and NFS protocols, providing shared storage for cloud or on-premises applications.

• Supports SMB and NFS protocols.
• Can be mounted by multiple VMs simultaneously.
• Offers standard and premium tiers for performance needs.

Memory trick: Think of Azure Files as your classic network drive, but in the cloud.

Azure Cosmos DB's global distribution capabilities allow data to be replicated across multiple Azure regions. For read-heavy workloads, deploying read replicas in regions geographically close to users significantly reduces read latency by serving data from the nearest replica.

• Replicate data across any number of Azure regions.
• Reads served from the closest replica for lowest latency.
• Requires specifying preferred regions for client SDK.
• Consistency level choice impacts read latency trade-offs.

Memory trick: Replicas Reduce Round Trips for Reads.

Azure Cosmos DB's Core (SQL) API is a NoSQL document database designed for high-performance, globally distributed applications, capable of storing unstructured JSON data with flexible schemas, making it ideal for high-volume IoT telemetry.

• Supports JSON documents with flexible schema.
• Offers high throughput and low-latency access.
• Provides robust SQL-like querying capabilities for JSON.

Memory trick: Cosmos DB Core handles IoT's JSON flow.

Strong consistency in Azure Cosmos DB guarantees that all reads return the most recent committed version of an item. This provides the highest level of data consistency across all replicas, at the cost of potentially higher latency and lower throughput compared to weaker models.

• Reads always see the latest committed write.
• Global consistency across all regions.
• Highest data consistency guarantee.
• Can result in higher latency for reads and writes.

Memory trick: Strong, Bounded, Session, Prefix, Eventual: The consistency spectrum.

Azure Queue Storage is a service for storing large numbers of messages. You access messages from anywhere in the world via authenticated calls using HTTP or HTTPS. A queue message can be up to 64 KB in size, and a queue can contain millions of messages, up to the total capacity limit of a storage account.

• Simple, scalable, durable message queuing.
• Messages up to 64 KB.
• Accessed via REST API (HTTP/HTTPS).
• Ideal for decoupling application components and asynchronous processing.

Memory trick: Queue for Quick, Simple Messages.

PartitionKey and RowKey form the unique primary key for entities in Azure Table Storage, determining data distribution and query performance.

• PartitionKey groups related entities.
• RowKey uniquely identifies an entity within a partition.
• Queries on PartitionKey and RowKey are most efficient.
• A good design balances write distribution and read performance.

Memory trick: Think of 'P'artition as the 'P'rimary grouping, and 'R'ow as the 'R'ecord within.

When listing blobs in Azure Blob Storage, the `prefix` parameter allows you to filter the results to only include blobs whose names begin with the specified string, effectively simulating listing contents of a virtual directory.

• Filters blobs server-side, improving efficiency.
• Useful for querying 'virtual directories' in flat blob storage.
• Can be combined with `delimiter` for hierarchical listing.

Memory trick: Prefix points to the folder's path.

Bounded Staleness is an Azure Cosmos DB consistency level that guarantees that reads are always within a specified number of versions or a specified time interval of the latest writes. It provides a balance between strong consistency and eventual consistency, allowing for higher throughput and lower latency than Strong consistency.

• Reads lag behind writes by at most 'K' versions or 'T' time interval.
• Offers a balance between strong and eventual consistency.
• Suitable for globally distributed applications.
• Higher throughput and lower latency than Strong consistency.

Memory trick: Consistency Choices: Strong, Bounded, Session, Consistent, Eventual.

Azure Cosmos DB is well-suited for IoT solutions due to its ability to handle high-volume, high-velocity data ingestion, flexible schema, and low-latency access.

• Scales horizontally for high throughput.
• Schema-agnostic (NoSQL APIs).
• Low-latency reads and writes.
• Supports geospatial, time-series, and other complex queries.

Memory trick: Cosmos DB is the 'Cosmic' solution for IoT's vast data.

The Azure Blob Storage Archive tier is an offline tier optimized for rarely accessed data that can tolerate several hours of retrieval latency, offering the lowest storage cost.

• Lowest cost storage tier for blobs.
• Optimized for rarely accessed data.
• High latency for retrieval (hours).
• Ideal for long-term backups, archival, and compliance data.

Memory trick: Cool, Hot, and Archived: Blob Storage has tiers, not just one.

The lowest-cost storage tier for Azure Blob Storage, optimized for rarely accessed data with flexible latency requirements (hours).

• Lowest storage cost.
• Highest retrieval latency (hours).
• High retrieval cost.
• Ideal for long-term retention and compliance.

Memory trick: Think of Hot, Cool, and Archive as a 'temperature' scale for data access.

The Azure Cosmos DB Core (SQL) API is the native API for Cosmos DB, designed for JSON documents. It provides a flexible schema, low latency access, and a powerful SQL-like query language for querying data.

• Native API for Azure Cosmos DB.
• Optimized for JSON documents.
• Supports flexible schema (schemaless).
• Offers a rich SQL query language.

Memory trick: SQL is the core, Mongo for compatibility, Cassandra for speed, Gremlin for graphs, Table for keys.

Block blobs are optimized for uploading large amounts of data efficiently. They allow files to be broken into smaller blocks, uploaded independently, and then committed as a single, complete blob, ensuring atomicity and integrity.

• Ideal for large files (GBs to TBs).
• Data uploaded in blocks (up to 50,000 blocks per blob).
• Blocks are committed using `Put Block List` operation.
• Ensures data integrity and allows for parallel uploads/retries.

Memory trick: Blocks for big stuff, Pages for VMs, Appends for logs, that's the blob story.

Azure Service Bus is a fully managed enterprise integration message broker. It can decouple applications and services, offering features like reliable asynchronous message delivery, message sessions for ordered processing, dead-lettering, and publish/subscribe capabilities.

• Enterprise messaging as a service.
• Supports both queues and topics.
• Guaranteed message delivery (at-least-once).
• Message sessions enable ordered processing.

Memory trick: Service Bus Secures Sequential Sending.

Read-Access Geo-Redundant Storage (RA-GRS) replicates your data to a secondary region hundreds of miles away from the primary region. It provides read access to the data in the secondary region, allowing for high availability and disaster recovery, even if the primary region becomes unavailable.

• Geo-redundant: data replicated to a secondary region.
• Provides read access to data in the secondary region.
• Offers eventual consistency for reads from the secondary.
• Highest durability and availability for Blob Storage.

Memory trick: Redundancy: Local, Zonal, Geographic, Read-Access Geographic.

Automates the process of tiering blobs to different access tiers (Hot, Cool, Archive) or deleting them based on rules, optimizing storage costs.

• Moves data between Hot, Cool, and Archive tiers.
• Rules are based on age, last modified, or last accessed time.
• Helps optimize storage costs and meet compliance requirements.

Memory trick: Think of lifecycle management as an automated 'storage butler' for your blobs.

Azure Table Storage is a NoSQL key-value store that allows for storing large amounts of structured, non-relational data. It's highly available, scalable, and cost-effective for scenarios requiring fast lookups on simple data models.

• NoSQL key-value store.
• Stores structured, non-relational data.
• Highly scalable and available.
• Cost-effective for large datasets.

Memory trick: Tables for simple keys, Cosmos for global scale, Mongo for compatibility.

The `ListBlobs` operation in Azure Blob Storage allows specifying a prefix to filter the returned blobs, effectively listing blobs within a virtual directory.

• Server-side filtering for efficiency.
• Treats hierarchical data like folders.
• Can be combined with delimiters for directory enumeration.
• Reduces data transfer and processing.

Memory trick: Listing blobs with a prefix is like searching a folder with a specific starting name.

Choosing an effective partition key in Azure Cosmos DB is crucial for performance and cost. A good partition key distributes data evenly and supports frequent query patterns by allowing single-partition queries, where all relevant data for a query resides within one logical partition.

• Distributes data across logical and physical partitions.
• Impacts query performance and cost (single- vs. cross-partition).
• Should have high cardinality and spread request units evenly.

Memory trick: Partition by the popular path for performance.

The Azure Cosmos DB Cassandra API provides a highly scalable, globally distributed, and low-latency database service for Apache Cassandra applications.

• Ideal for time-series, IoT, and archival data.
• Supports Cassandra Query Language (CQL).
• Offers high throughput and low latency for large datasets.

Memory trick: Choosing the right Cosmos DB API is like picking the perfect tool from a specialized toolbox.

The visibility timeout in Azure Queue Storage determines how long a dequeued message remains invisible to other consumers. If the message is not deleted within this period, it becomes visible again for reprocessing.

• Controls message availability after dequeue.
• Used to handle intermittent processing failures.
• Default value is 30 seconds, maximum is 7 days.

Memory trick: Visibility is the key to retry success.

The official .NET client library for programmatically interacting with Azure Blob Storage, enabling operations on containers and blobs.

• Provides classes like BlobServiceClient, BlobContainerClient, BlobClient.
• Used for uploading, downloading, deleting, and listing blobs.
• Part of the Azure SDK for .NET.

Memory trick: Each storage service has its own dedicated 'tool kit' (NuGet package).

Azure Cosmos DB is well-suited for IoT data ingestion and processing due to its globally distributed, highly scalable, and schema-agnostic nature. Its ability to handle high write throughput and offer low-latency reads makes it ideal for storing time-series sensor data.

• Schema-agnostic (JSON document model).
• Globally distributed, multi-region capabilities.
• High write throughput (millions of operations/sec).
• Low-latency reads and rich query API.

Memory trick: Cosmos Captures Constant Change and Queries.

Azure Blob Storage is Microsoft's object storage solution for the cloud. It is optimized for storing massive amounts of unstructured data, such as text or binary data. Versioning automatically saves a new version of a blob each time it's modified or deleted, allowing for restoration of previous states.

• Stores unstructured data (e.g., images, videos, documents).
• Supports various access tiers (Hot, Cool, Archive).
• Versioning provides data protection and historical access.
• Highly scalable and durable.

Memory trick: Blob's Big Binary Backups, Globally.

Azure Files offers fully managed file shares in the cloud, accessible via standard SMB and NFS protocols. Zone-Redundant Storage (ZRS) ensures data is synchronously replicated across three Azure availability zones in the primary region, providing high availability.

• Provides SMB/NFS file shares.
• Accessible from multiple VMs simultaneously.
• ZRS offers redundancy within a single region across availability zones.

Memory trick: Azure Files is for familiar File Shares, ZRS for Zone Safety.

A service for storing large amounts of unstructured object data, such as text or binary data, in the cloud.

• Stores objects like images, videos, documents, and log files.
• Highly scalable to petabytes.
• Offers global accessibility and various access tiers (Hot, Cool, Archive).

Memory trick: Picking storage is like choosing a container; what fits best?

Azure Cosmos DB autoscale throughput allows a database or container to automatically and instantly scale its Request Units per second (RU/s) based on usage, providing cost-effective and dynamic performance management.

• Automatically scales RU/s up and down.
• Ideal for variable and unpredictable workloads.
• Minimizes manual capacity management.
• Billed for the highest RU/s provisioned in an hour, with a minimum.

Memory trick: Auto-scaling is like a smart thermostat for your database, adjusting as needed.

The choice of partition key and item ID to distribute data across logical and physical partitions for optimal performance, scalability, and cost.

• Partition key determines logical partition for data distribution.
• Item ID (document ID) must be unique within a logical partition.
• Choose partition key based on frequently accessed query patterns to minimize cross-partition queries.

Memory trick: Partitioning is like organizing a library: group similar books for easy finding.

Azure Blob Storage is Microsoft's object storage solution for the cloud, optimized for storing massive amounts of unstructured data. Read-Access Geo-Redundant Storage (RA-GRS) provides geo-redundant replication with read access to the secondary region.

• Stores unstructured data (blobs, files, images, videos).
• RA-GRS provides high availability and disaster recovery.
• Allows read access to data in the secondary region for lower latency and resilience.

Memory trick: Blobs for Big Binary, RA-GRS for Global Reads.

The process of dividing data into smaller, more manageable logical and physical partitions based on a partition key to optimize data distribution and query performance.

• Essential for scalability and performance.
• Choosing the right partition key is crucial.
• Impacts cost and throughput (RU/s).

Memory trick: Partitioning is like organizing a library: put similar books together for easy finding.

Read-Access Geo-Redundant Storage (RA-GRS) replicates data to a secondary region hundreds of miles away and provides read access to the data in the secondary region.

• Offers geo-redundancy for disaster recovery.
• Allows read access to the secondary endpoint.
• Provides the highest level of durability and availability.

Memory trick: Remember R.A.G.S. for Read-Access Geo-Redundant Storage, allowing reads from afar.

Azure Cosmos DB global distribution allows data to be replicated across multiple Azure regions. By configuring a single write region and multiple read regions, applications can achieve low-latency reads from the closest replica while ensuring strong consistency for writes in the primary region.

• Distribute data globally for high availability and low latency.
• Can configure single-region writes or multi-master writes.
• Client SDKs use `PreferredLocations` to route reads to nearest replica.

Memory trick: Reads follow proximity, Writes follow the primary.

Azure Table Storage is a NoSQL data store that offers a cost-effective way to store structured, non-relational data in the cloud. It's ideal for small, frequently read key-value data like application configuration settings due to its high availability and low cost.

• Key-value store for structured data.
• Highly available and scalable.
• Very cost-effective for large volumes of small data.
• Strong consistency within a partition.

Memory trick: Tables are Tiny, Tidy, and Terrific for Config.

Azure Logic Apps is a cloud service that helps you schedule, automate, and orchestrate tasks, business processes, and workflows when you need to integrate apps, data, devices, and services across enterprises or organizations.

• Visual designer for workflow creation.
• Supports long-running, stateful processes.
• Connects to hundreds of services via connectors.
• Ideal for integration and orchestration.

Memory trick: Logic orchestrates a long, step-by-step dance.

A highly scalable data streaming platform and event ingestion service that can process millions of events per second. It's ideal for big data scenarios like IoT telemetry and application logging.

• High-throughput event ingestion.
• Supports multiple concurrent consumers.
• Provides ordering guarantees within partitions.

Memory trick: Event Hubs is like a giant river for data, all streams flow in and multiple cities can drink from it.

A feature of Azure Service Bus queues and subscriptions that provides guaranteed ordered delivery and exactly-once processing of related messages.

• Ensures all messages with the same SessionId are processed sequentially.
• Messages within a session are handled by a single receiver.
• Crucial for scenarios requiring message order (e.g., order processing).

Memory trick: Service Bus has 'superpowers' for tricky message flows.

A publish/subscribe messaging component within Azure Service Bus that allows producers to send messages to a topic, and multiple subscribers to receive copies of those messages via subscriptions.

• Enables fan-out messaging.
• Supports multiple independent subscribers.
• Provides advanced features like filtering, dead-lettering, and transactional guarantees.

Memory trick: Service Bus Topics are like a newspaper, many subscribers get the same news reliably.

A feature in Azure Service Bus that allows you to group multiple send and receive operations into an atomic unit, ensuring that all operations succeed or all fail together.

• Guarantees atomicity for a sequence of operations.
• Crucial for reliable messaging scenarios where data consistency is paramount.
• Supports sending to queues/topics and receiving from queues/subscriptions within a single transaction.

Memory trick: Service Bus is the 'banker' of messages, ensuring all transactions are atomic.

Azure IoT Edge Modules are Docker-compatible containers that run Azure services, third-party services, or your own custom code directly on IoT Edge devices. They enable local processing and analytics at the edge.

• Containerized units of logic.
• Run directly on IoT Edge devices.
• Enable edge analytics, filtering, and pre-processing.
• Managed from the cloud via IoT Hub.

Memory trick: A factory machine module doing work right on the spot.

Azure Event Hubs acts as a front door for ingesting massive amounts of data from diverse sources, especially in big data and IoT scenarios.

• Handles millions of events per second.
• Supports multiple consumer groups for parallel processing.
• Provides configurable data retention for historical analysis.

Memory trick: IoT data flows through Event Hubs, the super-stream collector.

A message receiving mode in Azure Service Bus that provides explicit control over message completion or abandonment.

• Message is locked upon retrieval, not deleted.
• Requires explicit completion to remove from queue.
• Ensures messages are not lost if consumer fails.

Memory trick: PeekLock: See the message, take a lock, then decide its fate.

A feature in Azure API Management to control the number of requests clients can make to an API over a specific time period, preventing overuse and protecting backend services.

• Protects backend APIs from abuse.
• Enforces rate limits and quotas.
• Can be configured with burst capacity settings.

Memory trick: APIM is the traffic cop for your APIs, ensuring no one speeds or jams the lanes.

Azure Event Grid is a fully managed event routing service that enables event-driven architectures by routing events from various sources to different handlers.

• Supports publish-subscribe model.
• Offers advanced filtering for subscribers.
• Delivers events reliably with dead-lettering and retry policies.
• Integrates with numerous Azure services and custom webhooks.

Memory trick: The event grid announces news, and interested parties pick what they want.

A fully managed service that helps organizations publish, secure, transform, maintain, and monitor APIs.

• Acts as a facade for backend APIs (e.g., Azure Functions).
• Provides capabilities for authentication, authorization, usage quotas, and caching.
• Enables developers to expose APIs securely to internal and external consumers.

Memory trick: APIM is the 'bouncer' and 'manager' for your APIs.

A configuration setting for actions in Azure Logic Apps that specifies how to handle transient failures, such as network glitches or API rate limits, by automatically retrying the action.

• Common policies include Default, None, Exponential interval, and Fixed interval.
• Exponential interval is ideal for handling rate limits (429 errors) and transient network issues.
• Configured on individual actions, often within the connector properties.

Memory trick: Logic Apps are 'smart workers' that know how to politely wait for APIs.

An extension of Azure Functions that lets you write stateful functions in a serverless compute environment. It enables reliable long-running orchestrations and managing state across function invocations.

• Supports stateful workflows.
• Ideal for long-running processes, fan-out/fan-in.
• Automatically manages state, checkpoints, and restarts.

Memory trick: Durable Functions are like a persistent robot chef following a complex recipe, even if it has to pause for ingredients.

The Azure Functions Consumption Plan is a serverless hosting option that automatically scales and bills only for the resources consumed during function execution. A Blob trigger executes a function when a new or updated blob is detected in Azure Blob Storage.

• Consumption Plan: Pay-per-execution, automatic scaling, no server management.
• Blob Trigger: Event-driven by Blob Storage changes (new/updated blobs).
• Ideal for cost-effective, event-driven processing of files.
• Functions can be configured for long-running tasks within plan limits.

Memory trick: Consume only when an image triggers; no waste, just smart processing.

A pattern in Azure Durable Functions that defines stateful workflows programmatically. Orchestrator functions manage the execution of other activity functions, handling state, retries, and compensation.

• Defines reliable, stateful workflows.
• Manages function execution and state.
• Supports complex patterns like compensation and error handling.

Memory trick: Durable Functions are the conductor of a complex symphony, ensuring every part plays in order and restarting if a musician makes a mistake, or even undoing if needed.

A feature in Azure Service Bus that provides ordered handling of an unbounded sequence of related messages. All messages belonging to a session are processed by a single receiver, in order.

• Guarantees message order for a group of messages.
• Ensures messages from a session are processed by one receiver.
• Useful for conversational patterns or stateful workflows.

Memory trick: Service Bus Sessions are like a dedicated lane for each customer's messages, keeping them in perfect order.

The Azure API Management 'rate-limit-by-key' policy restricts the number of API calls a consumer can make within a specified time period, with the limit dynamically determined by a key value extracted from the request context.

• Enforces request quotas on a per-key basis.
• Key can be an expression (e.g., user ID, IP address, header value).
• Prevents backend systems from being overwhelmed.
• Configurable for different time periods and call limits.

Memory trick: A traffic cop limiting cars based on their unique license plate.

Azure API Management can act as a facade for backend APIs, abstracting their implementation details, transforming protocols (e.g., SOAP to REST), and applying policies uniformly.

• Hides backend complexity.
• Enables protocol translation.
• Applies security, caching, and throttling.

Memory trick: APIM is the universal translator and security guard for all your APIs.

A feature of Azure Service Bus that enables ordered and concurrent processing of related messages.

• Guarantees FIFO delivery for messages within a session.
• Ensures all messages for a session are processed by a single receiver.
• Useful for scenarios requiring strict message ordering per entity (e.g., customer, order).

Memory trick: Service Bus Sessions keep related messages in a tidy, sequential line.

A managed service that acts as a central message hub for bi-directional communication between your IoT application and the devices it manages. It provides secure, reliable, and scalable device-to-cloud and cloud-to-device messaging.

• Enables secure device connectivity.
• Ingests high-volume telemetry data.
• Provides device management capabilities (identity registry, twin, direct methods).

Memory trick: IoT Hub is the command center for your devices, managing their identities and ensuring their data gets through.

An Azure Functions trigger that allows a function to execute automatically when a new or updated blob is detected in Azure Blob Storage.

• Monitors a specified container for changes.
• Provides the blob's content or metadata to the function.
• Ideal for processing newly uploaded files.

Memory trick: Triggers are the 'start button' for your function, each button for a different event.

A configuration for actions in Azure Logic Apps that specifies how to automatically re-attempt failed operations.

• Handles transient errors (e.g., network issues, temporary service unavailability).
• Configurable with different types (e.g., exponential, fixed interval).
• Improves workflow reliability.

Memory trick: Retry Policy: If at first you don't succeed, try, try, try again!

Azure Service Bus PeekLock receive mode makes a message invisible to other consumers while it's being processed, allowing for explicit completion or abandonment. The queue's MaxDeliveryCount property dictates how many times a message can be delivered (and potentially abandoned) before it's automatically moved to the dead-letter queue.

• PeekLock ensures 'at-least-once' delivery with explicit settlement.
• Message is invisible during PeekLock duration.
• Abandoning or lock expiry returns message to queue.
• MaxDeliveryCount (on the queue) controls retry attempts before dead-lettering.

Memory trick: A locked package (PeekLock) gets retried until it's delivered or discarded (MaxDeliveryCount).

A hosting plan for Azure Functions where compute resources are dynamically allocated and deallocated based on demand. You pay only for the time your code is running and the memory it consumes.

• Scales automatically, including to zero.
• Pay-per-execution billing model.
• Ideal for event-driven, intermittent workloads.

Memory trick: Consumption plan is like a smart meter for your code, only charging when the lights are on.

An Azure API Management policy used to set the content of the request or response body.

• Allows modification of JSON, XML, or other body content.
• Can use expressions to dynamically transform data.
• Applied in either inbound or outbound processing sections.

Memory trick: APIM policies are the rules that shape your API's behavior.