Microsoft Azure Data Fundamentals flashcards

Azure Cosmos DB's MongoDB API allows developers to interact with Cosmos DB using MongoDB client drivers and tools, providing a globally distributed, multi-model database service with the flexibility of the MongoDB document model.

• Compatible with existing MongoDB applications and tools.
• Offers flexible schema for diverse and evolving data.
• Provides global distribution and high availability.
• Supports low-latency reads and writes at scale.

Memory trick: Think 'Flexible Scales Global Dashboards' for Cosmos DB's MongoDB API.

Azure Role-Based Access Control (RBAC) for Storage allows for managing access permissions to Azure Storage resources (like Blob Storage) using Azure Active Directory identities, assigning specific roles with defined permissions.

• Integrates with Azure Active Directory for identity management.
• Provides fine-grained access control at the resource group, storage account, or container level.
• Uses built-in roles (e.g., Storage Blob Data Reader, Contributor) or custom roles.
• Recommended for secure, centralized access management.

Memory trick: Storage Access: Keys are broad, SAS is temporary, RBAC is role-based.

A column property in SQL Server that automatically generates sequential numeric values when new rows are inserted into a table, commonly used for auto-incrementing primary keys.

• Automatically generates unique, sequential numbers.
• Typically used for primary key columns.
• Defined with a 'seed' (starting value) and 'increment' (value to add).

Memory trick: Identity is the key to auto-generated numbers.

A globally distributed, multi-model database service that supports document data (JSON) and offers schema flexibility, high-performance queries, and various consistency models.

• Stores data as JSON documents.
• Provides schema flexibility, allowing data models to evolve.
• Supports rich SQL-like queries over document data.
• Offers global distribution and various consistency models.

Memory trick: Cosmos DB is like a flexible 'cosmos' for your ever-changing data.

Azure Synapse Analytics dedicated SQL pool distributes table data across compute nodes to optimize query performance, with different strategies for different table types.

• Round-robin: even but random distribution
• Hash-distributed: distributes based on column value, good for large fact tables
• Replicated: copies entire table to each node, good for small dimension tables
• Optimized for analytical workloads

Memory trick: Synapse tables: round, hash, or replicate.

The GRANT SELECT statement in MySQL is used to provide read-only access to a specific database, table, or column for a user.

• Provides read-only access.
• Essential for implementing the principle of least privilege.
• Syntax: GRANT SELECT ON database.table TO 'user'@'host'.

Memory trick: GRANT for Giving Rights, REVOKE for Removing.

TDE encrypts entire database files at rest, protecting data on storage media without requiring application modifications.

• Encrypts data at rest (data files, log files, backups).
• No application changes required.
• Protects against unauthorized access to physical storage.

Memory trick: TDE: Total Database Encrypted, Transparently Done.

A column or set of columns in one table that refers to the primary key in another table, enforcing a link between the two tables.

• Establishes relationships between tables
• Enforces referential integrity
• Can define cascade actions (e.g., CASCADE DELETE)

Memory trick: Keys and constraints ensure data is always right.

A graph database API in Azure Cosmos DB designed for storing and querying highly interconnected data, ideal for relationships and network analysis.

• Uses the Gremlin query language.
• Optimized for efficient traversal of relationships.
• Suitable for social networks, recommendation engines, and fraud detection.

Memory trick: NoSQL documents, Gremlin graphs connections, Mongo is familiar, Cassandra wide columns.

A set of capabilities dedicated to big data analytics, built on Azure Blob Storage. It provides file system semantics, file-level security, and optimized scale.

• Petabyte-scale storage for big data.
• Hierarchical namespace for file system organization.
• Strong consistency for file operations.

Memory trick: Lakes are vast and organized for data analysis.

A spectrum of consistency guarantees for data replication in Azure Cosmos DB, ranging from strong to eventual.

• Strong: highest consistency, highest latency.
• Bounded Staleness: reads lag by 'K' updates or 'T' time.
• Session: consistent for a client session.
• Consistent Prefix: reads never see out-of-order writes.

Memory trick: Strong for finance, Eventual for chat, Session for you alone.

A property in Azure Queue Storage that specifies the duration a dequeued message remains invisible to other consumers.

• Prevents multiple consumers from processing the same message simultaneously.
• If a message is not deleted within the timeout, it reappears in the queue.
• Essential for implementing retry logic for transient processing failures.
• Can be extended during processing to handle longer tasks.

Memory trick: Messages in a queue are like packages: send, get, process, deliver (delete), or return if issues.

A globally distributed, multi-model database service for managing data at a planetary scale with guaranteed low-latency access and high availability.

• Supports multiple APIs (SQL, MongoDB, Cassandra, Gremlin, Table).
• Offers five well-defined consistency models.
• Provides elastic scalability for throughput and storage.

Memory trick: Cosmo's global speed meets all app needs.

The lowest-cost storage tier for Azure Blob Storage, optimized for rarely accessed, long-term archival data.

• Offers the lowest storage costs.
• Highest data retrieval latency (can take hours).
• High access costs for retrieval.
• Ideal for backups, compliance data, and raw data archives.

Memory trick: Think of storage tiers like temperature: Hot (active), Cool (less active), Archive (frozen in time).

A document database API for Azure Cosmos DB, optimized for storing and querying semi-structured JSON data.

• Stores data as JSON documents.
• Supports SQL-like query language (SQL API).
• Offers schema flexibility (schemaless).
• Ideal for web, mobile, gaming, and IoT applications with semi-structured data.

Memory trick: Cosmos is the king for querying JSON data.

A SQL clause used to filter the records that are returned by a SELECT statement based on specified conditions.

• Filters rows based on conditions.
• Can include logical operators (AND, OR, NOT).
• Often used with comparison operators (=, <, >, LIKE, IN).

Memory trick: WHERE do I find the data I want? By specifying conditions.

A LEFT JOIN (or LEFT OUTER JOIN) returns all records from the left table, and the matching records from the right table. If there is no match, NULLs are returned for the right side.

• Includes all rows from the 'left' table.
• Includes matching rows from the 'right' table.
• Returns NULL for right-table columns if no match.

Memory trick: Left for All Left, Right for All Right, Inner for Only Match, Full for All.

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

• Optimized for storing objects like images, videos, audio files, backups.
• Highly scalable, durable, and available.
• Supports different access tiers (Hot, Cool, Archive).
• Can be accessed directly via HTTP/HTTPS.

Memory trick: Think of 'Blobs' as big, shapeless containers for any kind of file.

A fully managed relational database service in Azure that provides built-in high availability, automatic backups, and patching.

• Platform-as-a-Service (PaaS)
• Minimal administrative overhead
• High scalability and availability

Memory trick: SQL choices: Managed, PaaS, IaaS, Data Warehouse.

Azure Table Storage is a NoSQL key-value store that allows you to store large amounts of structured, non-relational data with a flexible schema. It is a highly scalable and cost-effective service.

• Cost-effective for large datasets.
• Flexible schema (schema-on-read).
• Supports simple queries based on primary key and partition key.
• Ideal for storing web application data, address books, device information, and other metadata.

Memory trick: Think 'Table Storage: Cheap Keys, Simple Values, No Complex Queries'.

A referential integrity action that automatically propagates changes (deletes or updates) from the parent table to related rows in the child table, ensuring data consistency.

• When a parent row is deleted, child rows are also deleted.
• When a parent key is updated, child foreign keys are also updated.
• Ensures data consistency and prevents orphaned records.
• Used carefully due to its cascading effect on data.

Memory trick: CASCADE cleans up, SET NULL orphans, NO ACTION/RESTRICT prevent.

A deployment option for Azure Database for PostgreSQL that automatically scales compute capacity based on demand and pauses billing during periods of inactivity, optimized for intermittent and unpredictable workloads.

• Automatic compute scaling based on workload.
• Pauses billing during inactivity.
• Cost-effective for intermittent workloads.
• Ideal for dev/test, infrequent applications, and bursty workloads.

Memory trick: Serverless for savings on sporadic demand.

A system that provides fine-grained access management to Azure resources, including Storage accounts, by assigning roles to Azure Active Directory identities (users, groups, service principals).

• Integrates directly with Azure Active Directory (AAD).
• Grants permissions based on predefined or custom roles.
• Enforces the principle of least privilege.
• Allows managing access at the subscription, resource group, or individual resource level.

Memory trick: RBAC is like a 'bouncer' at a club, checking your role before you enter.

Different cost-performance tiers for storing unstructured data in Azure Blob Storage.

• Hot: frequently accessed, higher storage cost, lower access cost.
• Cool: infrequently accessed (min 30 days), lower storage cost, higher access cost.
• Archive: rarely accessed (min 180 days), lowest storage cost, highest access cost.

Memory trick: Hot for now, Cool for later, Archive for forever.

A core capability of Azure Cosmos DB that allows your data to be replicated across any number of Azure regions worldwide, providing low-latency access and high availability.

• Replicates data across multiple Azure regions.
• Ensures low-latency data access for users globally.
• Provides high availability with automatic failover during regional outages.

Memory trick: Cosmos DB makes your data a 'global star', always close and always shining.

Azure SQL Managed Instance is a fully managed, intelligent, scalable cloud database service that provides the broadest SQL Server engine compatibility.

• Near 100% compatibility with SQL Server (on-premises).
• Supports SQL Agent, CLR, cross-database queries.
• Lift-and-shift existing SQL Server applications to Azure.

Memory trick: Managed Instance: SQL Server's cloud twin.

Using Azure Blob Storage to store and serve large unstructured media files (videos, audio, images) for applications like streaming platforms.

• Highly scalable for petabytes of data.
• Offers high availability and durability.
• Integrates well with Content Delivery Networks (CDNs) for global low-latency access.
• Supports different access tiers for cost optimization.

Memory trick: Blob is best for big binary files, like movies and music.

An API in Azure Cosmos DB that enables users to interact with Cosmos DB using Apache Cassandra's open-source SDKs and tools.

• Wire protocol compatible with Apache Cassandra.
• Allows migration of existing Cassandra apps with no code changes.
• Fully managed, scalable Cassandra experience.

Memory trick: Cassandra apps plug into the Cassandra API.

A feature in Azure Cosmos DB that enables all configured regions in a globally distributed account to accept both read and write operations.

• Enhances global write availability and reduces write latency.
• Requires careful consideration of conflict resolution policies.
• Provides active-active distribution for write operations.

Memory trick: Global needs multi-write for worldwide reach, consistency for order, feed for changes.

A fully managed cloud database service that provides near 100% compatibility with the latest SQL Server database engine, suitable for lift-and-shift migrations.

• Near 100% SQL Server compatibility
• Supports SQL Server Agent, cross-database queries, DTC
• Fully managed PaaS service
• Isolated virtual network environment

Memory trick: Migrate SQL: Managed Instance for compatibility, PaaS for simplicity, VM for control.

Read Replicas in Azure Database for PostgreSQL allow you to scale out read-heavy workloads by creating read-only copies of your primary database.

• Improves read scalability and performance.
• Asynchronous replication from primary.
• Can be created in the same or different regions.

Memory trick: Read Replicas: Replicate for Reads, Relieve Primary.

A service for storing large numbers of messages that can be accessed from anywhere in the world via authenticated HTTP or HTTPS calls.

• Decouples application components.
• Provides at-least-once message delivery.
• Highly scalable and cost-effective for message queuing.

Memory trick: Queues line up messages for processing.

A database object that provides fast lookup of data in a table, similar to an index in a book. It speeds up data retrieval operations on a table at the cost of additional storage and slower data modification operations.

• Improves query performance, especially for WHERE clauses and JOINs.
• Can be clustered (sorts and stores data rows) or non-clustered (separate structure).
• Should be created on frequently queried or joined columns.

Memory trick: Index: The fast lane for your data.

A variable-length Unicode string data type in SQL Server that stores up to 4000 characters. It is suitable for storing text data that may contain characters from different languages.

• Stores Unicode characters, using 2 bytes per character.
• Variable-length, so it only uses as much space as needed.
• Good for internationalization and mixed character sets.

Memory trick: NVARCHAR: Flexible, global text.

A fully managed Apache Cassandra-compatible API within Azure Cosmos DB, allowing existing Cassandra applications to run in Azure with minimal changes.

• Supports Cassandra Query Language (CQL).
• Leverages Cosmos DB's global distribution and scalability.
• Ideal for lift-and-shift migrations of Cassandra workloads.
• Provides high availability and low latency.

Memory trick: Migrate with the same name: Cassandra to Cassandra.

The Azure Cosmos DB Cassandra API enables Apache Cassandra applications to interact with Azure Cosmos DB as if it were a native Cassandra database. It provides the benefits of a fully managed, globally distributed NoSQL database while maintaining compatibility with Cassandra client drivers and tools.

• Wire protocol compatible with Apache Cassandra.
• Allows migration of existing Cassandra applications with minimal code changes.
• Leverages Cosmos DB's global distribution, elastic scalability, and high availability.
• Supports Cassandra Query Language (CQL).

Memory trick: Think 'Cassandra API: Seamless Cloud Move for Elephant Data'.

An exact numeric data type in SQL Server that stores numbers with a fixed precision and scale. It is used for financial data or any values where exact decimal precision is critical.

• Syntax: DECIMAL(P, S), where P is precision (total digits) and S is scale (digits after decimal point).
• Precision includes digits on both sides of the decimal point.
• Provides exact storage, unlike FLOAT or REAL which are approximate.

Memory trick: Decimal: Precision, Scale, Exact.

The highest consistency level in Azure Cosmos DB, guaranteeing that reads always return the most recent committed version of an item, and writes are globally replicated before being acknowledged.

• Reads always see the latest committed write.
• Highest data consistency guarantee across all regions.
• Highest latency for writes, lowest throughput compared to other levels.
• Ensures no data loss and strong consistency even with global distribution.

Memory trick: Consistency levels are like 'promises' about your data's freshness: Strong is a firm handshake, Eventual is a casual nod.

A feature in Azure Database for MySQL that allows you to replicate data from a primary server to up to 10 read-only replica servers, enabling scale-out of read-heavy workloads and disaster recovery.

• Asynchronous replication.
• Replicas can be in different regions.
• Improves read performance and disaster recovery posture.
• Write operations are handled by the primary server only.

Memory trick: Read Replicas: Global libraries for speedy reads.

The native API for Azure Cosmos DB, designed for document data (JSON), offering high performance, flexible schema, and global distribution.

• Supports JSON documents natively.
• Offers five consistency models.
• Ideal for web, mobile, and IoT applications requiring low-latency access.

Memory trick: NoSQL for JSON speed, Gremlin for connections, Table for simple, Cassandra for wide columns.

An access tier for Azure Blob Storage suitable for storing large amounts of data that is infrequently accessed (at least 30 days) but requires quick access when needed.

• Lower storage cost than Hot, higher access cost than Hot.
• Minimum retention period of 30 days.
• Ideal for short-term backups, disaster recovery, and older, less frequently used datasets.

Memory trick: Hot, Cool, Archive: Know your data's temperature for storage.

Azure Cosmos DB is Microsoft's globally distributed, multi-model database service for mission-critical applications, offering guaranteed low latency, high availability, and elastic scalability.

• Globally distributed with multi-region write capabilities.
• Guaranteed low latency (single-digit milliseconds).
• Supports multiple APIs (NoSQL, MongoDB, Cassandra, Gremlin, Table).
• Elastic scalability for throughput and storage.

Memory trick: Cosmos is the one true star for global, fast, and flexible data.

A feature of Azure Cosmos DB that enables applications to write data to any of the configured regions, not just a single primary write region.

• Provides low-latency writes globally.
• Enhances high availability and disaster recovery.
• Requires careful conflict resolution strategy.

Memory trick: Global writes mean multi-master magic.

An Azure Cosmos DB API that offers wire-protocol compatibility with existing Apache Cassandra applications.

• Allows seamless migration of Apache Cassandra workloads to Azure Cosmos DB.
• Supports Cassandra Query Language (CQL).
• Benefits from Cosmos DB's global distribution, elastic scalability, and high availability.
• Compatible with existing Cassandra SDKs and tools.

Memory trick: Cosmos DB is a 'universal adapter' for different NoSQL databases.

An Azure Cosmos DB API that supports graph data models and the Gremlin query language for highly interconnected data.

• Ideal for modeling relationships between entities (e.g., social networks, recommendation engines).
• Uses Apache TinkerPop Gremlin for graph traversal queries.
• Efficiently performs multi-hop queries across connected data.
• Benefits from Cosmos DB's global distribution and scalability.

Memory trick: Gremlin is for 'graph' relationships, like a spider's web.

A variable-length Unicode string data type in SQL Server that can store up to 2 GB of character data, optimizing storage for varying string lengths.

• Stores Unicode characters (e.g., international languages, emojis).
• Variable-length, so storage is efficient for diverse string lengths.
• Can store a very large amount of text (up to 2 GB).
• Preferred over deprecated TEXT data type.

Memory trick: NVARCHAR(MAX) for all your variable Unicode text needs.

A compute tier for Azure SQL Database that automatically scales compute, pauses when inactive, and bills based on consumed compute, suitable for intermittent workloads.

• Automatic compute scaling
• Consumption-based billing
• Automatic pausing for inactivity
• Ideal for unpredictable, burstable workloads

Memory trick: SQL's serverless tier adapts to your workload and budget.

An access tier optimized for storing data that is infrequently accessed, but still requires immediate retrieval. It balances lower storage costs with slightly higher access costs compared to the Hot tier.

• Optimized for infrequently accessed data
• Lower storage cost than Hot, higher than Archive
• Higher access cost than Hot, lower than Archive
• Immediate retrieval (milliseconds)

Memory trick: Hot for quick, Cool for casual, Archive for ancient.

Metadata about the data distribution in tables and indexes that the query optimizer uses to create efficient execution plans.

• Used by query optimizer
• Impacts query execution plan efficiency
• Outdated statistics can lead to poor performance
• Should be updated regularly or automatically

Memory trick: Optimize queries: check plans, update stats, tune indexes.

Always Encrypted is a SQL Server and Azure SQL Database feature that protects sensitive data inside the database from unauthorized access, even from database administrators.

• Client-side encryption, keys never leave client.
• Data encrypted at rest, in transit, and in memory.
• Protects against high-privileged users (DBAs).

Memory trick: Always Encrypted: Always Protected, Even from Admins.

An API for Azure Cosmos DB that supports graph database models and queries using the Apache TinkerPop Gremlin traversal language.

• Ideal for highly connected data like social networks, recommendation engines.
• Allows efficient traversal of nodes (vertices) and edges (relationships).
• Provides powerful graph query capabilities.

Memory trick: Gremlin maps the graph of connections.

A security feature that combines Azure Active Directory identities with Azure Role-Based Access Control to provide fine-grained permissions for accessing data in Azure Storage accounts.

• Allows assigning specific roles (e.g., 'Storage Blob Data Contributor') to AAD users or groups.
• Provides identity-based authentication and authorization.
• Offers a more secure and manageable alternative to shared access keys for production environments.

Memory trick: AAD and RBAC are the gatekeepers of blobs.

Azure Cosmos DB offers financially-backed service level agreements (SLAs) for throughput, latency, availability, and consistency for globally distributed applications.

• Guarantees single-digit millisecond latency for reads and writes.
• Offers 99.999% availability for multi-region accounts.
• Provides elastic scalability of throughput and storage.

Memory trick: Cosmos DB: Game-changer for global, fast data.

A NoSQL key-value database service within Azure Cosmos DB that provides high throughput and low latency for structured, non-relational data, compatible with Azure Table Storage.

• Key-value store for structured, non-relational data.
• Compatible with Azure Table Storage SDKs.
• Offers schema flexibility, allowing attributes to vary.
• Provides high throughput and low latency, cost-effective for simple scenarios.

Memory trick: For simple 'Keys' and 'Values', a 'Table' is perfect, like a well-organized index.

A type of NoSQL database that stores data in flexible, semi-structured documents (e.g., JSON, BSON), allowing for evolving schemas.

• Ideal for semi-structured data.
• Flexible schema, easy to evolve.
• Commonly used for user profiles, catalogs, content management.

Memory trick: Documents are flexible, graphs connect, keys are simple.

Azure Blob Storage offers an Archive access tier, which is an extremely cost-effective option for storing rarely accessed data with flexible latency requirements (up to several hours for retrieval). It ensures data durability and integrity for long-term retention.

• Optimized for long-term storage of rarely accessed data.
• Offers the lowest storage cost among all Azure storage tiers.
• Data retrieval can take several hours (rehydration).
• Suitable for compliance, backup, and archival scenarios.

Memory trick: Think 'Archive Blob: Decades of Data, Dirt Cheap, but Slow to Get'.

A table distribution strategy in Azure Synapse Analytics where rows are distributed across compute nodes based on a hash function applied to a designated column, optimizing query performance for join and filter operations on that column.

• Distributes data based on a hash of a chosen column.
• Best for large fact tables with frequent joins/filters on the distribution column.
• Requires a column with high cardinality (many distinct values).
• Minimizes data movement during query execution.

Memory trick: Hash for high cardinality joins, Replicated for small dimensions, Round-robin for staging.

A graph database service within Azure Cosmos DB that enables modeling and querying highly connected datasets using the Apache TinkerPop Gremlin query language.

• Optimized for storing and querying relationships between entities.
• Uses the Gremlin traversal language for powerful graph queries.
• Ideal for social networks, recommendation engines, fraud detection, etc.
• Data is stored as vertices (nodes) and edges (relationships).

Memory trick: Gremlin is like a 'spider' expertly navigating its web of connections.

Session consistency guarantees that within a single client session, all writes are visible to subsequent reads, and reads are monotonic. It provides a good balance between consistency and performance for interactive applications, ensuring a consistent user experience.

• Guarantees Read-Your-Own-Writes within a session.
• Guarantees Monotonic Reads and Monotonic Writes within a session.
• Offers better performance and availability than Strong or Bounded Staleness.
• Most commonly used for client-centric applications where users interact with their own data.

Memory trick: Think 'Strong, Bounded, Session, Consistent, Eventual' for the consistency spectrum.

Organizes data into one or more tables (relations) of rows and columns, with predefined schemas and strong consistency.

• Enforces data integrity through schemas, primary keys, and foreign keys.
• Provides ACID (Atomicity, Consistency, Isolation, Durability) properties.
• Uses SQL for querying and data manipulation.

Memory trick: Relational Ensures Reliability for Records