AWS Certified Solutions Architect - Associate (SAA-C03) Course
Design secure, resilient, fast and cost-optimized AWS architectures for SAA-C03: short lessons, then diagrams you complete, trace and build yourself.
Inside this course
Exercises you will solve
Services with the most lessons
- Amazon RDS
- Amazon S3
- Amazon VPC
- AWS Identity and Access Management (IAM)
- Amazon DynamoDB
- Amazon EC2
- AWS DataSync
Try a lesson
Restore the encryption dependency
Fill the service that Parameter Store uses to decrypt the SecureString value.
Amazon EC2
AWS Systems ManagerHow a lesson works
- ExplanationOrganize configuration with parameter paths
- Fill the blanksName the path and protect the value
- ExplanationFollow an encrypted parameter read
- Complete the diagramRestore the encryption dependencyThe exercise you just tried
- ExplanationAuthorize both the parameter and its key
- Trace a requestTrace the two authorization checks
- ExplanationStore once, retrieve safely at runtime
- Build the diagramRebuild the secure configuration read
- ExplanationWhat to remember
- 5 to 10 short steps, one at a time.
- Feedback at once: an exercise says what was wrong as soon as you answer.
- No videos: you read and solve at your own pace.
Course scope
The course follows the official SAA-C03 exam guide and covers all 4 domains and 14 tasks.
Design secure access to AWS resources2 free43 lessons
An IAM role is an identity with permissions that another identity can temporarily assume. Unlike an IAM user, a role has no permanent password or access keys. Assuming it creates a role session with temporary credentials.
AWS Identity and Access Management (IAM) maintains the definitions that govern access to AWS resources. For role-based access, you use IAM to create a role, define who may assume it, and assign its permissions. These definitions persist until you change or delete them.
Cross-account access grants selected capabilities without combining accounts or transferring ownership. Network connectivity and membership in the same AWS organization do not automatically grant access. Two common patterns are assuming a destination-account role and accessing a resource directly through its resource policy.
AWS Organizations centrally manages multiple AWS accounts. A service control policy (SCP) limits the permissions available to identities in member accounts. It sets a permissions ceiling: an action outside that ceiling cannot be authorized by giving a user or role more IAM permissions.
A service control policy (SCP) in AWS Organizations limits the permissions available to principals in member accounts. Attach SCPs to the organization root, an organizational unit (OU), or an account. An account inherits applicable restrictions along its root-to-account path, including through nested OUs.
AWS Organizations provides the foundation for managing multiple AWS accounts. You create or invite accounts, arrange them into organizational units (OUs), and apply organization policies. OUs let you group accounts that need common governance boundaries.
AWS IAM Identity Center gives employees a central place to access assigned AWS accounts and applications. Its identity source determines where workforce identities come from. Choose the built-in Identity Center directory to manage users and groups there, connect Microsoft Active Directory, or connect an existing external identity provider.
AWS IAM Identity Center centralizes access for a workforce: employees and contractors who need to sign in to AWS accounts and supported applications. For centralized workforce access across AWS accounts, it is the recommended starting point. People use an AWS access portal to find their assigned accounts and access levels, rather than maintaining a separate IAM user in each account.
AWS Directory Service supplies or connects Microsoft Active Directory identities. It addresses directory needs such as maintaining AD users and groups and supporting workloads that depend on AD.
AWS Resource Access Manager (AWS RAM) lets an owner share supported resources without copying them or transferring ownership. A resource share combines three ingredients: the resources being shared, the principals receiving access, and the managed permissions defining the allowed actions.
AWS Resource Access Manager (AWS RAM) lets a resource owner share supported resources with other AWS accounts. The resource stays in the owning account; sharing does not copy it or transfer ownership. The share establishes which recipients can access it and which shared operations are available.
Effective permissions are the result for a particular caller, action, resource, and request context—not just a list of policy statements. An allow must cover the requested action and resource, and its conditions must match. An applicable explicit deny overrides an allow.
Identity federation lets employees use their existing directory identity instead of separate IAM users in each AWS account. An identity provider, or IdP, authenticates the employee and issues signed evidence of that authentication. AWS validates the evidence and maps the employee to role access; it does not need a copy of the directory password.
Federation lets a person authenticate through an identity provider and obtain AWS access without receiving an IAM user's long-term access keys. Authentication establishes who the person is; an AWS role session supplies temporary AWS access. Successful sign-in alone does not authorize access to AWS resources.
AssumeRole lets an authenticated caller obtain temporary credentials for an IAM role. Use it to switch responsibilities within an account or access another account without sharing that account's long-term credentials.
An Amazon Cognito identity pool lets an application obtain temporary AWS credentials for an authenticated user or, when enabled, an unauthenticated guest. Use it when a web or mobile application needs to call AWS services directly without embedding long-term access keys.
Amazon Cognito manages identities for web and mobile applications. Choose it when customers need to register, sign in, recover accounts, or sign in through an external identity provider. A Cognito user pool authenticates application users and issues tokens that an application or API can validate.
A Region is a separate geographic area containing multiple Availability Zones (AZs). An AZ consists of one or more discrete data centers with redundant power, networking, and connectivity. AZs in a Region are physically separated and connected by low-latency networking. Choose a Region for geographic placement; choose AZs within it for placement across distinct failure boundaries.
A failure domain is a set of resources that can be affected by the same event. A physical host is one such domain: several virtual machines on that host can fail together. Adding virtual machines is redundancy, but it does not establish host isolation unless their placement separates them.
Least privilege means every user, role and application can do exactly what its task needs and nothing more. If its credentials leak or its code misbehaves, the damage stops at what it was allowed to do.
The AWS account root user is the account identity associated with its root email address. It has highly privileged access, including tasks that ordinary administrators cannot perform. Reserve root sign-in for tasks that specifically require it; use named, non-root identities for everyday administration.
An identity-based policy is a JSON document that defines permissions for an IAM user, group, or role. Attach a policy directly to a user for individual permissions, or to an IAM group to give its member users a shared set of permissions. A group is a collection of users, not an identity that signs in or makes requests.
Start with what the workload actually does, not a broad label such as “S3 access.” Our example is an invoice reader that downloads existing objects using known keys under invoices/ in the billing-records bucket. It does not discover keys, upload files, delete objects, or change bucket settings.
Least privilege asks: what capabilities does this identity need for its assigned work? It limits unnecessary access. For example, an application that reads invoices should not also be able to delete them or change their storage permissions.
Separation of duties prevents one actor from controlling every stage of a sensitive operation. For a production release, assign proposal, approval, and execution to distinct responsibilities. Different role names are not enough: the requester must not also control the approval identity.
Defense in depth combines safeguards that address different failure modes. A network rule limits which connections can reach an application; application authorization decides what a caller may do. Passing the network check must not automatically grant access to data.
AWS CloudTrail records account activity, including who made an API request, when it happened, its source, and the requested action. A trail delivers records to an S3 bucket for retention; do not rely only on the console's Event history as your audit archive.
AWS Trusted Advisor security checks evaluate account and resource configurations against AWS best practices. They flag conditions that deserve attention and recommend corrective actions. A warning means a configuration presents a potential risk; it does not, by itself, prove that someone exploited it. Trusted Advisor provides advice rather than automatically enforcing the recommended configuration.
The shared responsibility model separates security of the cloud from security in the cloud. AWS protects the physical facilities, hardware, underlying networking, and virtualization layer that run its services. Customers protect their data and configure the access and workload controls they manage.
Multi-factor authentication (MFA) requires different factor categories, such as a password plus possession of an authenticator. Two passwords are not MFA. A passkey can provide MFA through possession of its credential plus local verification with a PIN or biometric.
Credential rotation means replacing a credential, moving its consumers to the replacement, and retiring the old credential. Generating a new secret is not enough if applications still use the old one or AWS still accepts it.
Authentication establishes who is making a request. A trusted system validates evidence and associates the request with a principal: an identity such as a user or an assumed role session. This applies to both people signing in and workloads using credentials.
An identity-based policy describes what a user or role may do. A resource-based policy is attached to a supported resource, such as an S3 bucket or Lambda function, and describes which principals may access it. Its Principal identifies an account, role, user, or AWS service receiving permission.
Role-Based Access Control (RBAC) starts with a job, not a person. Define the operations that job needs, then limit their resource and environment scope. A reports analyst might need s3:GetObject for objects under one reports prefix, not write access or access to every bucket. People with the same approved responsibility can use the same role.
Attribute-Based Access Control (ABAC) uses attributes in policy conditions to decide which resources a requester may access. In AWS, a principal tag describes the requesting identity, while a resource tag describes the target. A Project tag can let one shared policy separate several teams without listing every team's resources.
Role-Based Access Control (RBAC) groups permissions around job functions. An auditor receives permissions to inspect records; an operator receives permissions to run approved operational tasks. Access follows an identity's assigned responsibility, with permissions scoped to the resources that responsibility covers.
Blast radius is the potential reach of a failure or compromise. For a stolen identity, ask which resources it can access, which permissions it can change, and which other identities it can become. Permission to read customer records establishes potential exposure; it does not prove that those records were read.
An AWS Control Tower landing zone is a configured starting point for a multi-account environment. It establishes shared governance resources and account baselines so that each team does not have to assemble its own security foundation. The baseline supports consistent logging, access, and oversight; it does not make every workload automatically secure or compliant.
A resource-based policy is attached to a resource, such as an Amazon S3 bucket. It can grant access and can also place explicit restrictions on requests to that resource. A statement with "Effect":"Deny" creates an explicit deny when that statement matches the request.
An AWS service can legitimately access your resource on someone else's behalf. The confused deputy problem arises when that service uses its trusted access for an unintended caller or source. The service can be correctly authenticated while the request is still associated with the wrong origin.
A data lake often separates objects into prefixes such as raw/ and curated/. A bucket policy is a resource-based JSON policy attached to an S3 bucket. It identifies the principal, permitted or denied actions, affected resources, and any conditions. Use specific role principals and narrow permissions rather than granting broad access.
An AWS KMS key has its own authorization controls. Permission to read an encrypted object or manage a storage service does not automatically include permission to use its KMS key. This lesson focuses on customer managed keys, whose policies you control.
An employee with an Active Directory account does not need a separate IAM user just to access AWS. With federated access, the employee authenticates using a directory identity and accesses AWS through an IAM role. This avoids maintaining a second personal account and long-term AWS credentials for each employee.
Design secure workloads and applications49 lessons
Externalized configuration keeps environment-specific values outside the application build artifact. The same container image or executable can run in staging and production while receiving different database endpoints, timeouts, and feature settings.
An application needs AWS credentials to sign AWS API requests. Instead of putting long-lived access keys in source code, images, or configuration files, assign the workload an IAM role. The role defines the permissions available to the application; temporary credentials let it act with those permissions.
Parameter Store, a capability of AWS Systems Manager, stores named configuration values outside application code. An application retrieves a value by name instead of embedding it in its source code or deployment image.
A database password embedded in source code or a machine image is difficult to replace and easy to copy accidentally. With AWS Secrets Manager, the application stores a secret identifier in its configuration and retrieves the credential at runtime. A secret can hold related fields together, such as a username and password.
AWS Secrets Manager is designed for secrets such as database passwords, API keys, and access tokens. Parameter Store, a capability of AWS Systems Manager, stores application configuration such as service endpoints, environment settings, and sensitive values.
A VPC endpoint lets workloads reach a supported service without sending that traffic through an internet gateway or NAT gateway. The workload does not need a public IP address. Choose the endpoint type supported by the service and appropriate for the access you need.
AWS PrivateLink lets an application reach a supported service privately through an interface VPC endpoint. You select subnets in your VPC, and AWS creates an endpoint network interface, or ENI, in each selected subnet. The application connects to an ENI's private IP address; this path needs neither an internet gateway nor a NAT gateway.
Start with what the application must reach. Routed VPC connectivity, such as VPC peering, lets workloads address resources in another VPC by their private IP addresses. It suits applications that need network-level communication across several workloads, especially when either side must initiate connections.
Network allowlisting permits explicitly approved connections and denies other connections by default. Start with an application dependency, not with a broad rule such as “allow the private network.” For each dependency, record the source that initiates it, the destination that receives it, the transport protocol, and the destination port.
An HTTPS client sends a TCP request from a temporary source port, such as 51000, to the server's destination port 443. The response reverses those roles: its source port is 443 and its destination port is 51000.
A security group filters traffic at a resource's network interface. A network ACL, or NACL, filters traffic entering or leaving a subnet. For a request between instances in different subnets, the applicable controls on both sides must permit it. Permission from one control cannot override a block from another.
When an application starts a TCP connection without choosing a local port, the operating system assigns an available ephemeral port from its configured range. The assignment belongs to the socket, not to each packet. Ephemeral means temporarily assigned; a long-lived connection can keep that port for hours.
An AWS Network Firewall firewall policy brings together references to rule groups and settings for handling unmatched traffic. A rule group is a reusable collection of rules. The policy combines stateless and stateful rule groups rather than treating them as interchangeable choices.
Amazon VPC provides your network and its basic traffic controls. Use security groups to restrict traffic at workload network interfaces and network ACLs to filter traffic at subnet boundaries. These controls match network details such as addresses, protocols, and ports—not application payloads.
An application cannot trust a caller merely because a request contains a username or user ID. Authentication requires evidence that a trusted system can validate. After validation, the application can associate the request with an identity.
Network reachability lets traffic arrive at an endpoint. Request authorization decides whether that caller may perform the requested operation in the current context. A private endpoint still needs authorization; a reachable public endpoint can still reject a request.
An Amazon Cognito user pool is a managed directory that authenticates application users. It supports registration, sign-in, account recovery, and user attributes. Your application registers an app client in the pool to define how it uses authentication. A pool can also accept sign-in through configured social or enterprise identity providers.
Amazon GuardDuty continuously analyzes AWS activity for signs of threats. Its foundational sources include CloudTrail management events, VPC flow logs, and DNS query logs. These reveal API actions, network connections, and domain lookups—not the contents of network packets.
Amazon Inspector discovers supported resources and assesses them for vulnerabilities after you enable the relevant scanning types in an AWS Region. Its coverage includes EC2 instances, container images in Amazon ECR, and Lambda functions. It produces findings: records of identified security issues and the resources they affect.
Amazon GuardDuty detects signs of threats: “Does this activity suggest someone is misusing my AWS environment?” Amazon Inspector assesses weaknesses: “Does this resource have vulnerable software or network exposure that needs attention?” Choose by the question you need answered, not simply because both services produce security findings.
Amazon Macie discovers sensitive data in Amazon S3 objects. Its data identifiers describe what to look for in object content, such as financial information, personal information, or an organization's internal identifiers. They classify content; they do not grant or deny access to it.
Amazon Macie answers a data discovery question: “Which objects in Amazon S3 contain sensitive information?” Use it to identify data such as personal information or payment card numbers so you can review how that data is stored and protected.
AWS Security Hub CSPM brings security findings and configuration-check results into one place. CSPM means cloud security posture management: understanding how securely your cloud resources are configured and where attention is needed.
Amazon GuardDuty answers: “Does observed activity suggest a threat?” It analyzes AWS activity signals to detect signs of malicious or unauthorized behavior. Choose it when a workload needs threat detection, such as identifying suspicious use of AWS credentials.
A distributed denial-of-service attack, or DDoS attack, tries to exhaust capacity so legitimate users cannot use an application. Network and transport-layer attacks can flood bandwidth or overwhelm connection handling. AWS Shield Standard automatically protects AWS customers against common attacks at these layers, without a separate subscription or an activation step.
AWS WAF inspects HTTP and HTTPS requests at supported application endpoints. A web access control list, or web ACL, holds the rules and default action that decide whether a request can continue. You associate the web ACL with the endpoint; you do not deploy WAF as a separate proxy server.
AWS Shield provides managed protection against distributed denial of service (DDoS) attacks. A DDoS attack uses distributed sources to overwhelm capacity or resources and make an application unavailable. Network traffic floods and floods of connection attempts are examples: the attack does not need to contain malicious web request content.
A distributed denial-of-service attack tries to exhaust a resource so legitimate users cannot use it. Start by naming that resource. A volumetric flood consumes bandwidth; a protocol attack such as a SYN flood targets connection establishment or network state; an application-layer flood consumes work through HTTP requests. Blocking traffic after the scarce resource has already been consumed is too late.
SQL injection happens when untrusted input becomes executable SQL. Joining request text onto SELECT * FROM orders WHERE order_id = lets that text change the query's meaning. The database executes the result with the application's database permissions, not the requester's intended permissions.
Cross-site scripting (XSS) happens when an application lets untrusted content cross the boundary from data into executable browser content. A support portal might intend to display a customer message but insert it as raw HTML instead. Attacker-controlled markup can then cause the browser to execute code.
Cross-site scripting (XSS) and SQL injection share a basic mistake: untrusted data becomes instructions. The distinction is the interpreter that gives those instructions meaning. An attack arriving in a web request is not necessarily an attack on the browser; follow the input to where it is interpreted.
A subnet route table supplies forwarding rules for traffic leaving a subnet. Each route pairs a destination, written as a CIDR address range, with a target, such as local VPC routing or an internet gateway. The destination describes which packets match; the target describes where to send them.
A VPC is a regional virtual network. Its IPv4 CIDR block defines an address range, such as 10.20.0.0/16. Each subnet receives a nonoverlapping range contained within a VPC CIDR block. Instances take private IPv4 addresses from their subnet.
Source Network Address Translation (source NAT) changes a packet's sender address. It lets a workload with only a private IPv4 address initiate connections to internet destinations without receiving its own public IPv4 address.
IP routing selects a forwarding path. It examines a packet’s destination IP address and uses routing information to choose a next hop, such as a gateway. Selecting that next hop does not itself translate the packet’s source or destination address.
A public NAT gateway lets workloads with private IPv4 addresses initiate internet connections without assigning public IPv4 addresses to those workloads. Replies return through the translation state, but internet hosts cannot initiate unsolicited connections through the NAT gateway.
Network segmentation limits which workloads can reach one another. Start with the required source, destination, protocol, and port; then choose subnet placement and traffic rules. A subnet belongs to one Availability Zone, and its associated route table determines where traffic goes. A subnet name does not determine its connectivity.
A trust boundary marks a change in security assumptions: who controls a component, which identity is acting, or how much confidence the receiver can place in incoming data. Crossing it requires explicit checks appropriate to the interaction. It is a logical distinction, not necessarily a network edge.
An IPv4 address has 32 bits. In CIDR notation, the number after the slash counts the bits fixed as the network prefix. The remaining bits vary to identify addresses within that block. A prefix of length p therefore contains 2^(32 − p) total addresses: a /24 has 256, while a /26 has 64.
A trust boundary is a point where a flow enters a different security context. To find one, follow the data and ask three questions: does its exposure change, does the receiving component rely on a different identity, or does a different team have administrative control?
A leased line is a carrier-provisioned circuit between specified endpoints, with contracted capacity and service terms. The carrier may use shared infrastructure with logical isolation; private connectivity does not require an exclusive fiber strand along the whole route.
Transport Layer Security (TLS) protects application traffic against interception and modification while it travels between endpoints. HTTPS is HTTP carried over TLS. Encrypting a disk or database does not protect these connections; encryption at rest and encryption in transit solve different problems.
IPsec protects traffic at the IP layer, so a gateway-to-gateway tunnel can carry traffic for many applications without changing those applications. For external cloud connectivity, AWS Site-to-Site VPN uses IPsec between a customer network gateway and an AWS tunnel endpoint.
An encryption claim needs a protection boundary: the endpoints where protection starts and stops. IPsec can protect IP traffic between security gateways across a routed network. MACsec protects Ethernet frames between participating link-layer devices.
AWS Site-to-Site VPN carries traffic between networks through encrypted IPsec tunnels. Here, an on-premises application reaches an EC2 instance by its private IP address. We use an internet-based VPN connection: encryption protects the traffic crossing the public network.
AWS Client VPN is a managed remote-access VPN service. A user runs a compatible VPN client and connects to a Client VPN endpoint. The encrypted tunnel protects traffic between the user's device and that endpoint; use application encryption, such as HTTPS, when protection must continue to the application.
AWS Client VPN connects individual remote devices to a network. A user runs compatible VPN software and connects to a managed Client VPN endpoint. Choose this model for people working from home or traveling who need access to private resources.
AWS Direct Connect provides connectivity from your network to AWS without using the public internet as the transport path. A virtual interface (VIF) is a logical interface on that connection. Its VLAN separates traffic, and its BGP routing session exchanges reachability information.
Both services connect an on-premises network to AWS. AWS Direct Connect provides connectivity through a Direct Connect location, bypassing the public internet. A typical AWS Site-to-Site VPN carries network traffic inside encrypted IPsec tunnels over an existing internet connection. Here, VPN means this internet-based deployment unless stated otherwise.
Determine appropriate data security controls53 lessons
A data-access request asks whether a particular principal, such as an IAM role, may perform an action on a resource. For example, reading an S3 object uses s3:GetObject. Permission to list a bucket is a different action and does not itself permit reading its objects.
In AWS Key Management Service (AWS KMS), permissions apply to particular actions on particular keys. For a customer managed key, you control who can use the key and who can administer it. These are separate responsibilities, not two names for the same access.
A workload that reads or writes data does not automatically need permission to delete it or change how long it survives. Separate a data-use role from a protection-administration role. Give the workload only its required operations on the intended resources; reserve deletion, lifecycle changes, retention changes, and backup administration for separately authorized roles.
AWS Lake Formation controls access to data described by the AWS Glue Data Catalog. The files remain in Amazon S3. Catalog tables describe their columns, formats, and S3 locations, giving permissions a table-level meaning rather than just a bucket-and-object meaning.
AWS Glue helps make data discoverable and usable. Its crawlers can discover schemas and populate the Glue Data Catalog, which stores metadata such as columns, formats, and data locations. Glue ETL jobs read, transform, and write the actual data. A catalog entry describes data; it does not clean or convert the files.
Recovery Point Objective (RPO) is the maximum acceptable loss of recent data, expressed as time. A five-minute RPO means recovery must preserve data through a point no more than five minutes before the disruption. It asks: How much recent work can we afford to lose?
Recovery Point Objective (RPO) is the maximum amount of recent data loss the business accepts, expressed as time. A 30-minute RPO requires recovery to a data state no more than 30 minutes before the disruption. Set the objective for each dataset according to the business impact of losing its changes.
A Recovery Time Objective (RTO) is the business target for how long a service may remain unavailable after a disruption. It is not a database restore duration or a provider guarantee. Agree on the failure being covered, such as loss of a Region, and which business operations must resume.
A recovery point represents a recoverable state of your data. Backup frequency controls the spacing between scheduled recovery points. Choose it from the recovery point objective (RPO): the maximum acceptable data loss measured in time. Daily backups can leave nearly a day of changes unprotected; hourly backups reduce that gap, assuming jobs succeed and usable recovery points become available on time.
Database replication maintains another copy of changing data. After an initial copy, replication transfers ongoing changes, including inserts, updates, and deletes. This can support availability or read scaling, depending on the database and configuration.
Backup and restore supports operational recovery after deletion, corruption, or failure. A backup preserves a recoverable state; a restore uses that state to recover usable data and application functionality. The question is: Can we get the workload working again?
Backup and restore recovers a workload from a preserved state. A completed backup job proves that a backup was created; it does not prove that the application can recover within its business requirements.
A recovery point is a backup of a protected resource. For a snapshot-based backup, such as an Amazon EBS backup, it represents the resource's data at a particular time. Later changes to the live volume do not rewrite that earlier backup.
An AWS Backup plan is a reusable protection policy containing one or more backup rules. Rules define when backups run, how long they are retained, and any supported lifecycle transitions. A plan can apply consistent protection to many resources without separate scheduling scripts.
In an S3 general purpose bucket, an object’s key is its name. With S3 Versioning enabled, writing to an existing key creates a new version with its own version ID. The previous version becomes noncurrent rather than disappearing. An ordinary read returns the current version; a read with a version ID can retrieve an older one.
AWS Backup and Amazon S3 Glacier storage classes solve different problems. AWS Backup centrally manages backup protection for supported resources. S3 Glacier storage classes provide archival storage for S3 objects. The choice starts with the job you need done, not simply how long you need to keep data.
Recovery point objective (RPO) is the maximum acceptable data loss measured in time. If the newest usable recovery point is older than the RPO allows, protection is insufficient—even if recovery is fast.
Data classification assigns information to categories based on sensitivity and business impact. Assess the consequences of unauthorized disclosure, modification, loss, and unavailability—not just whether the data contains personal identifiers. Public information can still need strong protection against unauthorized changes or outages.
A retention period is an approved length of time to keep data, not a default chosen by the storage service. Start with classification: identify the data's purpose, sensitivity, owner, and applicable obligations. Financial evidence, customer records, and temporary diagnostic data can need different periods. Sensitivity alone does not determine a duration.
Data retention determines how long data must be kept and when it should be disposed of under an approved policy. Storage tiering chooses a storage class that fits the data's access needs and cost. A record can pass through several storage classes during one retention period.
Choose an S3 storage class by how often objects will be read, how quickly reads must complete, and how long the data must remain stored. S3 Standard suits frequent access. S3 Standard-IA suits infrequent access that still needs immediate reads. S3 One Zone-IA also provides immediate reads, but stores data in one Availability Zone; use it for data you can recreate, not your only irreplaceable copy.
An approved disposal policy becomes an executable rule only when you identify which data it covers, what starts its clock, and what action removes it. In Amazon S3, lifecycle filters can select objects by prefix or tags, while expiration conditions determine when selected objects become eligible for deletion.
Data retention specifies how long data should be kept. “Keep audit records for one year” describes the required outcome, but it does not itself stop anyone from changing or deleting those records during that year.
A retention setting says how long data should remain; an immutable retention control prevents early deletion. For Amazon S3, Object Lock protects individual object versions against permanent deletion or overwrite. It requires S3 Versioning. A time-based retention setting gives a version a retain-until date: protection lasts until that date, subject to the selected mode.
A legal hold prevents disposal of information needed for a legal matter or investigation. Start with a preservation inventory: the case reference, relevant records, timestamps, owners, locations, and copies. A case tag helps find evidence, but does not prevent deletion.
A legal hold preserves information for a legal matter or investigation until an authorized person explicitly releases it. A case closing does not itself change the storage control. Time-based retention instead protects information for a defined period; that protection ends when the retention deadline passes.
Encryption turns readable plaintext into ciphertext. Its confidentiality boundary depends on where encryption starts and where decryption happens—not simply on whether a resource is marked encrypted.
Key custody concerns where key material is held and who can operate it. AWS owned keys leave key management to AWS. AWS managed keys are managed by an AWS service in your account. A customer managed KMS key gives you control over its policy and lifecycle, but does not mean your application holds the underlying key material. With standard KMS-generated symmetric encryption keys, applications request cryptographic operations rather than retrieve that material.
Envelope encryption separates encrypting data from protecting the key that encrypts it. A data encryption key (DEK) encrypts the payload, such as a document, locally in the component handling that data. A separate key-encryption key (KEK), also called a wrapping key, encrypts the DEK.
Envelope encryption separates encrypting data from protecting the key that encrypts it. A data key encrypts the actual data. A KMS key protects that data key. The AWS service handles the bulk data; it does not send the entire object to KMS for encryption.
AWS CloudHSM provides hardware security modules in which you control cryptographic keys and access to them. An application can ask an HSM to perform an operation without receiving the key material used for that operation.
Both AWS KMS and AWS CloudHSM protect cryptographic keys with hardware security modules, or HSMs. The choice is not hardware protection versus software protection. It is how directly you must control the HSM and how much responsibility you want to take on.
Compliance means meeting applicable requirements and demonstrating that the required controls work. Start by classifying the workload's data and identifying obligations from laws, industry standards, contracts, and internal policies. Confirm applicability with the organization's legal, security, and compliance owners rather than choosing a framework simply because AWS supports it.
AWS Artifact Reports provides on-demand access to AWS security and compliance documents, including SOC reports, ISO certificates, and PCI reports. Use these when an auditor or your risk team needs evidence about AWS controls. Artifact does not inspect your workload or certify your application.
Data locality describes proximity between data and the computation or people that use it. Its purpose is efficient access: reducing unnecessary network movement and latency, and potentially reducing transfer costs. Running a processing job near the dataset it repeatedly reads is a locality choice.
A data residency requirement identifies where specified data may be stored or processed. Translate it into an explicit list of approved AWS Regions with your legal and compliance teams. Identify the covered data classes: customer records, for example, may have different restrictions from public assets.
Amazon CloudWatch provides operational visibility: how resources and applications are behaving. Metrics such as CPU utilization show changes over time, while application logs provide details about failures. Use this evidence to investigate performance, availability, and application health.
AWS Config records supported resource configurations as configuration items: point-in-time descriptions of resource settings and relationships. Enable recording for the resource types you want to check. A Config rule evaluates applicable resources against a requirement and reports results such as COMPLIANT or NON_COMPLIANT.
AWS Config rules ask whether a resource meets a defined requirement. A rule might require an ownership tag or prohibit a particular network setting. The baseline is the rule's policy, not the template that created the resource. A compliant result means the resource passes that rule; it does not certify every aspect of the resource.
Encryption coverage means the stored data and copies that a particular setting protects. Start by naming the storage resource, then list its snapshots, backups, replicas, exports, logs, and temporary files. Do not treat “the application is encrypted” as a useful boundary: one application can store data in several places.
Plaintext is readable data; ciphertext is its encrypted form. To distinguish client-side from server-side encryption, locate the encryption operation relative to the storage-service boundary. Ask what the storage service receives, not just whether the stored object is encrypted.
Envelope encryption separates bulk data encryption from key protection. A data key encrypts the object’s contents. A separate KMS key encrypts, or wraps, that data key. The service stores the encrypted data key with the encrypted object, not the plaintext data key.
Server-side encryption means the receiving service encrypts data before storing it and decrypts it for an authorized reader. Applications use normal storage requests rather than implementing encryption themselves. Use TLS as well: protection at rest does not protect data travelling over the network.
With client-side encryption, the application encrypts data before sending it to storage. The application can run in the cloud: “client-side” identifies where encryption happens, not where the computer is located.
Transport Layer Security (TLS) protects traffic against disclosure and undetected changes. During connection setup, the endpoints negotiate security settings and establish keys. In HTTPS, the client also validates the server certificate to check that it is connecting to the intended server.
AWS Certificate Manager (ACM) provisions and manages TLS certificates. For a public HTTPS website, request a public certificate: it lets a client authenticate the website's domain name during the TLS handshake. An integrated AWS service presents that certificate and terminates TLS; ACM itself does not receive the website's HTTPS traffic.
Mutual TLS (mTLS) establishes an encrypted connection that authenticates both the client and the server. Each peer presents a certificate that binds an identity to a public key. Each side must be configured with trusted certificate authorities; they do not have to trust the same authorities.
Transport Layer Security (TLS) protects application traffic against disclosure and undetected modification. Both server-authenticated TLS and mutual TLS (mTLS) provide this protection. Their difference is whose identity is verified, not whether traffic is encrypted.
Backup isolation keeps recovery copies outside the effective control of production systems and identities. If production credentials are stolen, the attacker should not automatically gain permission to delete backups, shorten retention, or disable the keys needed to restore them.
Every DynamoDB table automatically stores data across multiple Availability Zones within one AWS Region. DynamoDB manages these copies and the infrastructure failures they protect against. You do not select AZs, create standby instances, or promote an AZ replica. This built-in protection does not create a copy in another Region.
Amazon S3 Object Lock protects individual object versions against permanent deletion and overwriting. It works with S3 Versioning: enable Object Lock on the bucket, then apply retention settings or a legal hold to the versions you need to preserve. Enabling Object Lock alone does not give every version a retention period.
An AWS KMS key is a logical resource with an identifier, permissions, and underlying key material. Rotation changes the material used for new encryption operations. A rotation schedule helps limit the period during which one material version is used to encrypt new data.
Certificate renewal replaces a certificate before its validity ends. Success means the endpoint serves the replacement—not simply that a certificate authority issued it. Otherwise, clients can reject connections when the old certificate expires.
Design scalable and loosely coupled architectures2 free135 lessons
REST, or Representational State Transfer, is an architectural style, not a protocol or product. A resource is something an application exposes, such as an order. Its identifier, such as /orders/123, names the resource rather than the database table or server that stores it.
A REST interface exposes resources through paths and HTTP methods. For an orders API, GET /v1/orders/{id} retrieves an order, while POST /v1/orders creates one. Define the required parameters, request body, response fields, and status codes, such as 201 for successful creation and 404 for a missing order. This contract, which can be described with OpenAPI, is what clients depend on.
Amazon API Gateway provides a managed entry point for clients to call backend functionality. Start by choosing the API type: HTTP API and REST API both support HTTP request-and-response applications. An HTTP API can serve a RESTful application; the product names do not describe two different application styles.
A sustained-rate budget controls how quickly requests can keep arriving over time. A burst budget allows a short concentration of requests without granting a permanently higher rate. Choose both: a safe average can still hide a burst large enough to overwhelm a backend.
Exponential backoff controls when a caller retries after a retryable failure. It is reactive: an unsuccessful attempt triggers a wait, and successive failures lead to progressively longer retry delays. For example, an illustrative schedule might wait one second, then two, then four. Backoff does not control the arrival rate of new requests.
Amazon SQS is a managed message queue. A producer sends a message describing work, and a consumer, often called a worker, receives it later. The producer needs the queue to accept the message, not a worker to be ready at that moment.
Amazon SQS holds messages until consumers can work on them. Choosing Standard or FIFO determines what consumers can assume about delivery order and repeated messages—not whether the application can ignore failures.
Both services support loose coupling: a producer sends a message without directly calling the application that processes it. Choose between them by asking whether the requirement is to distribute a message, buffer work, or do both.
Amazon MQ is a managed message broker service for Apache ActiveMQ and RabbitMQ. Amazon SQS is a managed queue service with its own service API. Both can decouple applications, so “we need a queue” is not enough to choose between them.
AWS Transfer Family provides managed file-transfer server endpoints. Existing clients connect using SFTP, FTPS, or FTP, while files are stored in Amazon S3 or Amazon EFS. AWS operates the endpoint infrastructure; you configure its protocols, network placement, identities, and storage permissions.
AWS Transfer Family provides managed file-transfer endpoints for clients using protocols such as SFTP, FTPS, and FTP. Choose this model when a person, partner application, or script connects and decides which files to upload or download.
An application cache stores reusable objects or query results under keys. Here, an application on Amazon EC2 uses Amazon ElastiCache for cached copies and Amazon RDS as its system of record. A usable cache hit avoids a database read; the database remains authoritative.
In cache-aside, the application checks a faster, optional copy before reading the authoritative database. A hit supplies a usable cached value. A miss means the requested value is absent: the application reads the database, caches the result, and returns it.
In cache-aside, the application manages a cached copy while the database remains authoritative. Here, an application on Amazon EC2 uses Amazon ElastiCache for cached values and Amazon RDS for stored records. The diagram shows request and response channels, not the timing of individual operations.
Write-through caching updates the backing database and the cache on the write path, before acknowledging the operation as fully successful. The database remains the authoritative source; the cache holds a replaceable copy for faster reads.
Cache-aside populates a cache because someone requests data: the application checks the cache, reads the database after a miss, and caches the result. Write-through populates or refreshes a cache because someone writes data: both the database and cache updates must complete before the write is acknowledged as fully successful.
Amazon ElastiCache holds in-memory copies of data so repeated reads can avoid the database. In this example, an application on Amazon EC2 uses Amazon RDS as its source of truth. The application implements the caching pattern; ElastiCache does not automatically discover database changes or fetch missing database rows.
With node-based ElastiCache, you choose node types and topology, and pay for provisioned nodes even when they are lightly used. For Valkey and Redis OSS, a shard holds part of the keyspace and has a primary that accepts writes. With cluster mode disabled, there is one shard; with cluster mode enabled, data can be partitioned across multiple shards using a cluster-aware client.
Amazon DynamoDB is a durable key-value and document database. Its tables hold the application's source data, accessed through DynamoDB operations such as GetItem and Query. Adding a cache does not replace that storage role.
Edge caching keeps reusable responses near viewers. In this architecture, Amazon CloudFront delivers shared assets from an Amazon S3 bucket, which remains the origin: the authoritative source. Edge locations are distributed delivery locations, not Regions or Availability Zones.
Edge computing runs selected logic near the users or devices involved in a workload. It changes where computation happens. A gateway evaluating a new sensor reading locally is doing edge computing even if it has never seen that reading before.
Amazon CloudFront is a content delivery network for HTTP and HTTPS content. A distribution connects viewer-facing delivery settings to an origin, the source of the content. CloudFront routes viewers to an edge location selected for low latency, not simply the geographically closest location.
A website served straight from one Region is slow for users far away: every request crosses the world. Amazon CloudFront is a content delivery network. It answers from edge locations close to the user and keeps copies of your files there.
Amazon CloudFront is a content delivery network for HTTP and HTTPS applications. It can cache reusable responses at edge locations and serve them closer to users. Choose it for delivering web pages, images, downloads, video, or APIs, especially when caching can reduce latency and work at the origin, the backend that supplies content.
Loose coupling lets one component change without forcing its callers to understand the change. Callers depend on an explicit interface contract: supported operations, required inputs, returned fields and their meanings, and expected errors. For an order lookup, that might mean an order identifier as input and a documented order status as output.
Separation of concerns asks, “Which responsibility belongs here?” Loose coupling asks, “How much must this component know about, or depend on, another component?” They support each other, but they describe different properties of a design.
A stateless processing instance can handle a request correctly without remembering an earlier request. Each request carries explicit context, such as authentication information, the operation to perform, and a cart identifier. The instance uses that context to find any required records in an external store.
A microservice is a service with a focused responsibility that can be deployed without releasing the whole application. Choose boundaries around business capabilities, such as ordering and notifications. Each capability should contain the rules and data access needed to do its job, rather than depending on a shared business-logic deployment for every change.
Separation of concerns describes how responsibilities are organized. It asks which component owns a rule or behavior, and which interface other components use to reach it. Deployment boundaries describe which pieces of software are released and run together. These are different questions.
Microservices describe how an application is divided into services. Containers describe how application code and its dependencies are packaged and run. These are separate choices: a package boundary does not establish a service boundary.
An Amazon SQS standard queue can deliver a message more than once. A worker can also finish a change and crash before deleting the message. Idempotent processing means that processing the same operation again does not repeat its business effect.
In event-driven architecture, a producer publishes a record of something that happened, and a consumer decides how to react. OrderPlaced describes a fact; UpdateFulfillmentStatus requests an action. Here, an order component publishes the fact without directly calling the fulfillment component.
A publisher sends a message to a topic, rather than contacting every recipient. Amazon SNS performs fan-out: it delivers a copy to each matching subscription. Adding a subscription does not require the publisher to send another copy itself.
Event-driven architecture describes how an application organizes its behavior: components react to events, which record facts such as OrderPlaced. It is an architectural style because it shapes how responsibilities interact across the application.
A work queue distributes work among competing consumers. Several workers read from one queue, but each message is intended to be processed by one worker, not independently by every worker. The workers usually perform the same job, such as generating a thumbnail.
Idempotency means repeating the same logical operation does not repeat its intended effect. A request can succeed even when its response is lost, so a timeout is not proof that nothing happened. Retrying an order request should not create another order.
Message ordering preserves a required sequence between different events. Idempotency ensures that repeating the same logical event does not repeat its intended business effects. Ordering asks, “Which event comes first?” Idempotency asks, “What happens if this event happens again?”
An event records something that happened, such as an order being placed. With Amazon EventBridge, a producer publishes that event to an event bus. Rules on that bus select interested targets, so the producer does not need their addresses or processing logic.
Loose coupling means a producer does not call each consumer directly. With either Amazon EventBridge or Amazon SNS, the producer publishes to an intermediary, and consumers can be added without adding consumer addresses to the producer.
AWS Lambda runs your code without requiring you to provision servers. For ordinary on-demand, event-driven functions, an invocation passes an event to a handler, which performs a bounded piece of work and finishes. Examples include validating an API request or processing a newly uploaded object.
AWS Lambda provides compute: it executes your function code. That code might validate an order or calculate its price. AWS Step Functions provides orchestration: it coordinates tasks according to a workflow definition called a state machine.
Scaling out adds resources serving a workload; scaling in removes them. An extra application instance adds useful capacity only if work can reach it and be processed independently of the other instances.
Vertical scaling changes the capacity of an existing resource. For Amazon EC2, you choose an instance type; for an instance-based Amazon RDS database, you choose a DB instance class. A useful choice adds capacity to the resource that is actually limiting the workload: its bottleneck.
Horizontal scaling changes how many resources serve a workload. Adding application instances or workers is scaling out; removing them is scaling in. Each resource handles part of the work.
Vertical scaling changes an existing resource's capacity. The resize lifecycle starts before the change: confirm compatibility, prepare for interruption, apply the change, validate the result, and either accept it or roll back. A larger configuration is not automatically a compatible configuration.
An EC2 instance type defines a virtual server's processor, memory, storage capabilities, and networking capabilities. Start with the workload's limiting resource: compute-optimized families emphasize CPU, memory-optimized families emphasize RAM, and storage-optimized families emphasize local storage performance. General purpose families balance resources; accelerated computing families provide hardware such as GPUs or specialized accelerators.
An EC2 instance in the running state provides compute capacity and incurs instance usage charges, even when its application is idle. A reboot restarts the operating system without releasing that capacity: billing continues, RAM contents are lost, and attached storage remains. For an EBS-backed instance, stopping shuts down the instance but keeps its identity and EBS volumes for a later start.
For an Amazon RDS DB instance, capacity has several dimensions. The DB instance class supplies CPU and memory and sets limits on network and storage I/O. Allocated storage is the space available for database files. More storage space does not automatically mean more CPU or memory.
An Amazon RDS read replica is a separate database instance that receives changes from a source database and can serve read queries. Moving suitable reads to it frees source capacity, but does not add write capacity. This lesson uses RDS for MySQL or PostgreSQL DB instance read replicas, rather than Aurora replicas.
Horizontal scaling changes the number of resources serving a workload. Adding instances or workers is scaling out; removing them is scaling in. Vertical scaling changes the capacity of an individual resource, such as its CPU or memory. These terms describe how capacity changes.
An automatic capacity-control policy uses a measured signal to decide when capacity should change. Amazon EC2 Auto Scaling applies these decisions to the desired number of EC2 instances in a group. Adding instances helps only when those instances can share the work that is limiting throughput.
An Auto Scaling group maintains a desired amount of EC2 capacity. Minimum capacity sets its floor, maximum capacity sets its ceiling, and desired capacity is the amount the group currently tries to maintain. In a group that counts each instance equally, a minimum of 2, desired capacity of 4, and maximum of 8 means the group aims to run four instances within a range of two to eight.
Amazon Aurora Serverless is a configuration of Aurora, which is part of Amazon RDS—not a separate alternative to all of RDS. This lesson compares Aurora Serverless v2 with provisioned RDS database instances. Both provide managed relational databases; the important difference here is how their compute capacity changes.
A content delivery network (CDN) delivers HTTP content through distributed edge locations. Amazon CloudFront is AWS's CDN. Routing selects an edge using network conditions and proximity, not geographic distance alone. Reusing content at the edge can reduce latency and repeated work at the origin, the source of the content.
AWS Global Accelerator gives clients a stable entry point for applications that use TCP or UDP. A standard accelerator directs traffic through AWS edge locations and across the AWS global network to regional application endpoints. This can improve performance by reducing how much of the journey depends on public internet routing.
A container image packages application files, required libraries, language runtimes, and startup metadata. A container is a running instance of that image. For example, an API image can include the application and its required Python packages, so each destination does not need those packages installed separately.
An orchestrator places container workloads on compute capacity and keeps their actual state moving toward a declared desired state. For a long-running service, you specify what to run, its resource requirements, and how many replicas should exist. You do not manually choose a host for every replacement.
Containers describe application packaging and execution. A container image packages an application, its dependencies, and startup information. A container is a running instance of that image, executed by a container runtime using operating-system isolation.
A container image packages application code, libraries, and other files needed to start an application. A container is a running instance of that image. The same image can supply many running containers.
A private ECR repository holds your application images in an AWS account and Region. For this example, create the repository with aws ecr create-repository --repository-name orders --region us-east-1. Its registry hostname is 111122223333.dkr.ecr.us-east-1.amazonaws.com; replace the example account ID with yours. The repository must exist before the push.
Amazon ECS schedules tasks, not individual containers independently. A task definition is a versioned blueprint for a task. It specifies one or more containers, their images, CPU and memory settings, and configuration such as ports, logging, and permissions. Containers in the same task are scheduled together.
Amazon EKS provides a managed Kubernetes control plane. You describe the workload you want, and Kubernetes continually works to make the running workload match that description. This repeated comparison of desired state with actual state is called reconciliation.
Amazon ECS and Amazon EKS both orchestrate containers: they use application requirements to run workloads and maintain their desired state. The main difference is the interface your team works with. ECS uses an AWS-native orchestration model; EKS provides managed Kubernetes, using the standard Kubernetes API.
AWS Fargate provides compute for containers managed by Amazon ECS or Amazon EKS. AWS provisions and maintains the underlying compute infrastructure. You do not create worker-node fleets, choose host instances, or patch their operating systems. You still configure and manage your ECS or EKS workloads.
A load balancer gives clients an application endpoint instead of making them choose an individual server. In this example, an Application Load Balancer selects an eligible EC2 target from a target group. The diagram shows request and session-access paths, not replies or health probes.
A load balancer's health check asks whether a registered backend should receive new requests. For an Application Load Balancer (ALB), health checks are configured on the target group. Normally, ALB directs requests to healthy targets rather than unhealthy ones.
Start with the routing decision. An Application Load Balancer (ALB) understands HTTP requests at the application layer. It can send different hostnames or URL paths to different target groups. Choose it when, for example, /images and /checkout must reach different application services.
Content-based routing asks, “Which destination can handle this kind of request?” It examines request attributes and matches them to a suitable service or processing path. For example, a request for /checkout belongs with checkout code, not catalog code.
Elastic Load Balancing (ELB) offers different load balancer types because distributing web requests, distributing network connections, and inserting inspection appliances are different jobs. Start with the required protocol and routing behavior, rather than choosing by expected traffic volume alone.
Elastic Load Balancing gives clients an entry point while the application targets behind it change. Using an Application Load Balancer (ALB) as our example, a listener accepts requests on a configured protocol and port. Its rules select a target group: a registered pool of destinations and their traffic ports.
Session affinity, also called stickiness, attempts to send a returning session to its previous application target. This can support an application that keeps session data, such as a shopping cart, only in that target's memory. The routing assignment does not copy the session data elsewhere.
Session affinity, also called stickiness, lets a load balancer recognize returning traffic and reuse a previous target assignment. The identifying information differs: an HTTP cookie for Application Load Balancer (ALB) stickiness, or a source IP address for Network Load Balancer (NLB) stickiness.
Amazon Route 53 chooses what destination to return in a DNS answer. The client uses that answer to connect to an application endpoint. Route 53 does not receive and forward the application's HTTP requests or transport connections.
Separation of concerns assigns distinct responsibilities to components. A responsibility is cohesive when its behavior belongs together: checking whether an order is acceptable and recording its accepted state enforce the same business rules. Formatting a customer notification changes for different reasons and belongs elsewhere.
A producer creates work; a consumer, often called a worker, performs it. With message queuing, the producer submits a message to a durable queue instead of waiting for a worker to finish. Successful queue acceptance means submitted, not completed. This suits background work whose result can arrive later.
A queue accepting a message means that work was submitted, not completed. A consumer must perform the work and then acknowledge success. With Amazon SQS, an application-managed consumer acknowledges by deleting the message after successful processing.
Amazon SNS provides topic-based publish/subscribe messaging. A publisher sends a message to a topic, a named distribution point. Each subscription connects that topic to an endpoint that can receive messages.
Amazon MQ runs managed Apache ActiveMQ or RabbitMQ brokers. A broker accepts messages from producers and makes them available to consumers, so applications do not need to communicate directly or run at the same time. AWS handles broker provisioning and maintenance; you still configure messaging behavior and application connections.
AWS Lambda runs a function handler for an invocation. It suits short, bounded work triggered by an event, such as validating an order or processing a queue message. Each invocation must finish within the service's execution-duration limit; it is not a continuously running application process.
Amazon EC2 provides virtual servers called instances. You choose an operating system, install software, and run application processes. AWS manages the physical infrastructure; you manage the guest operating system, its patches, application dependencies, and the health of your application.
AWS Fargate runs containers as Amazon ECS tasks or Amazon EKS pods without you managing the underlying servers. AWS Lambda runs code in response to invocations. Here, Lambda means on-demand, event-driven functions; other Lambda compute options have different controls and billing.
Concurrency is the number of invocations executing at the same time. For standard AWS Lambda execution, each execution environment handles one invocation at a time. Under steady demand, estimate required concurrency as requests per second × average duration in seconds. For example, 60 requests per second taking 0.2 seconds each need about 12 concurrent executions. Bursts and variations in duration require additional headroom.
AWS Step Functions runs a state machine: a workflow definition containing states and transitions. Each run is an execution with its own input and progress. You can define the workflow in Amazon States Language, a JSON-based language, or use Workflow Studio.
Block storage presents an operating system with a sequence of addressable blocks, like a disk. The operating system or application decides how to organize those blocks. Most applications use a filesystem on the device: the filesystem supplies filenames, directories, and permissions. Some databases can instead use a block device directly.
Ephemeral storage is storage whose data you must be prepared to lose with its associated compute environment. It is defined by its retention guarantees, not by whether it uses SSDs, other disks, or memory. EC2 instance store provides temporary block storage on disks physically attached to the host, on supported instance types.
A block volume can have enough space but still be too slow. Describe speed using IOPS, the number of input/output operations completed per second; throughput, the amount of data transferred per second; and latency, the time an individual operation takes. Storage capacity alone describes none of these.
Object storage stores data as objects: data bytes with associated metadata, identified by a key within a bucket. In Amazon S3, an application addresses an object using its bucket and key, such as bucket product-assets and key images/item123.jpg. The slash is part of the key; a prefix such as images/ groups names rather than creating a traditional directory.
A shared file system provides files and directories that multiple servers access over a network. Each server mounts the file system into its own directory tree. Applications then use familiar file operations, such as opening, reading, writing, and renaming files.
Block storage exposes a disk-like device containing addressable blocks. The operating system issues reads and writes at positions on that device. Applications usually work through a filesystem, which translates file operations into block operations; some databases use block devices directly. Amazon EBS provides this disk interface for Amazon EC2.
Block storage exposes addressed blocks, not filenames. With Amazon EBS, an operating system typically creates a filesystem on the volume. That filesystem manages directories, permissions, and the metadata that records which blocks belong to each file.
Object storage and shared file systems can both hold documents, images, and application data. The important difference is the interface the application expects. Object clients identify objects by bucket and key and use API operations such as upload, retrieve, list, and delete.
An Amazon EBS volume provides block storage for an EC2 instance. Choosing its type starts with how the application reads and writes, not just how much data it stores.
Amazon S3 is object storage. In a general purpose bucket, each object contains data and metadata and is identified by a key. A key such as reports/june.csv looks like a file path, but its slashes form a naming prefix, not directories in a mounted file system.
Amazon S3 stores objects in buckets. Each object has a key, its name within the bucket, and a storage class, which determines storage and access characteristics. A general purpose bucket can contain objects in different storage classes.
Amazon EFS provides a managed file system that Linux clients mount using NFS. Multiple clients can use the same directories and files concurrently, making EFS useful for shared application content, home directories, and parallel processing of files.
Amazon FSx provides managed storage based on four different file system families. They are not interchangeable performance tiers: each preserves different protocols, application behavior, and management capabilities. Start with what the application requires, then choose capacity, performance, and availability within that family.
Amazon EBS provides a block device attached to an EC2 instance, much like a disk. The operating system can create a file system on it, or an application can use the blocks directly. EBS fits boot volumes and application or database data that needs an instance-attached disk.
Amazon S3 stores objects in buckets. An application identifies an object by its key and uses API requests such as GET and PUT to read or write it. This suits images, backups, logs, and application data handled as objects.
Amazon EFS provides elastic shared file storage over NFS for Linux workloads. Applications share a file system, and its storage grows and shrinks as files are added or removed. EFS is a strong starting point when ordinary shared Linux file access meets the application's needs.
A read replica maintains a copy of a source database and serves read queries. Sending suitable reads to it reduces read work on the primary. It does not move application writes off the primary.
Eventual consistency allows copies of data to differ temporarily while updates propagate. If updates stop and replication operates successfully, the copies eventually agree. The model alone does not promise a maximum waiting time or that a client immediately sees its own writes.
Read/write splitting sends changes to a writable primary and suitable queries to read replicas. Each replica maintains a copy of the primary's data. Moving reads away from the primary reduces competition for processing power, memory, and storage throughput.
In a conventional single-writer Aurora DB cluster, the writer handles database changes and Aurora Replicas provide additional compute for read-only queries. The writer and replicas use the same cluster storage volume; adding a replica does not create another independent, full copy of the database volume.
A replication lag budget is the amount of delay the business accepts between a committed update and its availability on a read replica. For example, a product-browsing page might accept updates appearing within five seconds. That is an illustrative business target, not a database guarantee.
A read replica adds capacity for reads that the application can send away from the primary database. First measure the peak eligible read demand: the reads you intend to offload, including their query mix and concurrency. Replicas do not increase the primary's write capacity.
A state machine defines a process as named states and allowed transitions. A state might invoke a worker, wait, or choose a branch. A transition moves to another state according to a result, condition, or event; it is not an arbitrary change of status.
Capacity planning anticipates the resources a workload will need to meet its service objectives, such as response time and throughput. It uses expected demand, growth, and measured resource performance to decide what capacity must be available.
Right-sizing asks, “What resource configuration fits this workload?” The answer must meet performance and availability requirements with justified headroom. It is not necessarily the smallest resource: too little capacity can cause slow responses or failures, while too much wastes resources.
Automatic storage expansion adds storage capacity as stored data grows. It is useful when a database keeps accumulating records, indexes, or logs and predicting the exact growth is difficult. A traffic spike alone does not necessarily require more storage: read requests can increase without adding much data, while a quiet data import can consume substantial space.
Amazon EC2 Auto Scaling manages EC2 instances in an Auto Scaling group: a collection treated as one unit for capacity management. It launches and terminates instances to maintain the group's desired capacity, and replaces instances that it detects as unhealthy.
DynamoDB measures read and write work separately. In provisioned mode, a read capacity unit (RCU) supports one strongly consistent read per second of an item up to 4 KB, or two eventually consistent reads per second of that size. A write capacity unit (WCU) supports one standard write per second of an item up to 1 KB.
Start with what should happen to each message. Amazon SQS provides a work queue: producers send messages, and consumers poll for work. Workers sharing a queue compete for its messages rather than each receiving a separate copy. This suits jobs such as processing an uploaded image. It is not a promise that a message can never be delivered again.
A serverless database removes the need to provision and maintain database hosts, but you still choose a data model and capacity settings. Automatic scaling follows demand within service limits; it does not guarantee unlimited throughput or eliminate every charge.
Amazon RDS operates relational databases for you, but you still choose the database engine. Relational workloads use tables, relationships, SQL queries, and transactions. For example, an order transaction can update an order and its inventory records together. These requirements establish the workload's needs; they do not by themselves distinguish MySQL from PostgreSQL.
Amazon DynamoDB is a fully managed NoSQL database. A table contains items, and each item contains named attributes. In a key-value model, an application retrieves an item by its key. In a document model, the item can also contain nested maps and lists, such as a delivery address or shopping-cart contents.
Amazon DynamoDB is a managed NoSQL database for key-value and document data. Amazon RDS runs managed relational databases. Start the choice with the application's access patterns: which records it retrieves, how it finds them, and how often those requests change.
Amazon DocumentDB and Amazon DynamoDB can both store nested, evolving document data. A product with optional attributes, a nested address, or a list of tags does not by itself make DocumentDB the better choice. The important distinction is how the application retrieves and changes those documents.
Amazon RDS is a managed relational database service suited to transactional workloads, often called OLTP. Typical requests retrieve one customer's details, insert an order, or update a few inventory records. They need short response times while many users make small reads and writes.
Amazon RDS is the managed service; Amazon Aurora is one of its database engine choices. The comparison here is Aurora MySQL-Compatible versus RDS for MySQL, or Aurora PostgreSQL-Compatible versus RDS for PostgreSQL. All support relational tables, SQL, and transactions, and all offload infrastructure tasks such as provisioning, backups, and patching to AWS.
A NAT instance is an EC2 instance configured to forward and translate traffic for other instances. It lets a workload in a private subnet initiate IPv4 connections to the internet without giving that workload a public IPv4 address.
VPC peering provides direct, private connectivity between two VPCs using their private addresses. The VPCs can belong to different accounts or Regions. Creating and accepting the peering request establishes the connection; it does not automatically add the subnet routes that applications need.
VPC peering provides direct private connectivity between two VPCs. It is nontransitive: peering A with B and B with C does not let A reach C through B. A needs its own connection to C.
A key-value data model associates a unique key with a value inside a collection or namespace. The key identifies the record; the value contains the application data. The basic operations are reading, writing, and deleting a record by key.
A relational data model organizes records into tables whose columns describe attributes. A primary key identifies a row. A foreign key references a key in a related table: for example, an Orders row can hold a customer_id that refers to Customers.
A document boundary decides which fields live together in one document and which live in separate documents. Start with the application's common reads and updates, not with a list of related business objects. For an order-details screen, identify the fields usually needed together: the order identifier, shipping address, and purchased items.
The relational data model commonly represents related things as separate rows. A Customers table can hold one row per customer, identified by a primary key, such as customer_id. Each row in Orders can contain that customer's identifier as a foreign key. The order points to the customer; it does not need to contain the customer's name.
A key-value data model associates a key with a value. In basic, opaque-value access, the database retrieves or replaces that value by key without interpreting its contents. Opaque means the application, rather than the database operation, understands the fields inside the value.
Amazon DocumentDB is a managed document database with MongoDB API compatibility. It stores BSON documents: JSON-like records that support fields, nested objects, arrays, and additional data types. A product document can keep its name, dimensions, and available colors together, matching how an application reads that product.
A graph data model makes connections part of the stored data. A node, also called a vertex, represents an entity such as an account or device. An edge represents a relationship between entities. For example, Account A —USES→ Device D says that a particular account uses a particular device. Multiple accounts can connect to the same device node, making that shared connection explicit.
Amazon Neptune is a fully managed graph database for storing connected data and querying its relationships. In a property graph, a vertex, also called a node, represents an entity. An edge represents a directed relationship between entities. Both vertices and edges can carry key-value properties.
Amazon Neptune is a graph database built for working with connected entities and their relationships. A relationship traversal starts at an entity and follows connections to other entities. For example, an application might follow a customer’s purchases to products, then follow those products to other customers who bought them.
Amazon OpenSearch Service is a managed service for search and analytics. In a managed domain, OpenSearch stores JSON documents in an index: a logical collection of related documents. A document might represent a product or one application log event.
AWS Batch schedules and runs noninteractive jobs: programs that start, do their work, and finish without someone operating them. Examples include generating reports, converting files, and running simulations. For container jobs, package the program and its dependencies into a container image; even a script runs inside a container.
AWS Batch and Amazon EMR can both process work without user interaction. A nightly schedule, large input files, or data stored in Amazon S3 does not distinguish them. The useful question is: What should the service manage for this application?
A Neptune Database cluster separates the instances that execute graph queries from the storage that holds the graph. Its shared cluster storage automatically replicates data across multiple Availability Zones in one Region. Storage replication protects data; it does not create more instances to execute queries.
Design highly available and/or fault-tolerant architectures44 lessons
A public hosted zone holds DNS records for a domain, such as example.com. Its records provide authoritative answers: the published information for that domain. To make the zone usable on the internet, configure the domain's parent delegation to use the name servers assigned to the hosted zone. Creating a zone alone does not redirect existing DNS delegation.
Amazon Comprehend is a managed natural language processing service. Its pretrained models turn unstructured text, such as reviews and support messages, into structured results without requiring you to train a model or manage inference servers.
Amazon Polly is a managed text-to-speech service: an application supplies written text and receives synthesized spoken audio. AWS operates the speech models and synthesis infrastructure. Your application still chooses the content, requests synthesis, and handles the resulting audio.
AWS Managed Services (AMS) takes on agreed day-to-day operations for your AWS infrastructure. It combines AWS operational expertise, automation, and established procedures for work such as monitoring, incident response, backup operations, and patch management. The exact responsibilities depend on the services and resources covered by your engagement.
A CIDR block describes an entire address range. An IPv4 prefix of /n contains 2^(32 − n) addresses. For example, 10.40.0.0/24 covers 10.40.0.0 through 10.40.0.255. A smaller prefix number means a larger range. Blocks must start on their boundaries: a /23 spans two third-octet values and starts at an even one, such as 10.40.0.0/23.
A network connection and a usable route are different things. A VPC peering connection provides direct private connectivity between two VPCs with non-overlapping address ranges. Accepting the connection does not automatically add the subnet routes needed to use it.
A disaster recovery strategy balances the loss a business can tolerate against the resources it keeps ready. Recovery point objective (RPO) is the maximum acceptable data loss measured in time. Recovery time objective (RTO) is the target maximum time to restore service after a disruption.
Failover transfers work from an unhealthy resource to a healthy alternative. It needs three things: failure detection, an alternative able to do the work, and a way to transfer traffic or processing responsibility.
Failover transfers work from an unavailable or unhealthy resource to an alternative capable of doing that work. The resource could be an application server, a database, or an entire deployment. Failover can support everyday availability: moving requests away from one failed server does not require declaring a disaster.
Pilot light keeps a small, essential core operating in a recovery location while the rest of the workload waits to be activated. In this example, an Amazon RDS database engine that supports Cross-Region read replicas continuously replicates to another Region. Application compute is absent until recovery.
Warm standby keeps a complete application environment running at reduced capacity in a separate recovery location. It can process requests at a limited scale, but normally does not receive production traffic. Recovery turns that working environment into the production environment.
Pilot light and warm standby both prepare a recovery location before a disruption. The important difference is not simply how many resources run there. It is whether the recovery application is already functional.
AWS Elastic Disaster Recovery protects servers by continuously copying disk changes into an AWS staging area. After an initial synchronization, the AWS Replication Agent sends changed blocks rather than repeatedly copying whole disks.
Opening database connections consumes time, memory, and CPU. A burst of application instances can exhaust connections even when each instance does little work. RDS Proxy sits between an application and a supported RDS or Aurora database. Applications connect to its endpoint rather than directly to the database.
Immutable infrastructure means releasing changes by replacing deployed compute, rather than installing new software on existing production hosts. For an EC2 application, build a new Amazon Machine Image (AMI) containing the approved operating system, packages, and application. A security patch becomes a new image release, not a manual edit to each server.
Infrastructure as code (IaC) describes infrastructure in files that a deployment tool uses to create and update resources. It answers: How is the infrastructure defined and managed? Version-controlled definitions make changes reviewable and help teams repeat a deployment.
Blue-green deployment separates preparing a release from sending users to it. Blue serves the current version while green is built alongside it. In this lesson, each environment is an EC2 application fleet, and the release does not install new software on the live blue instances.
Blue-green deployment answers: How does a release take over production traffic? The current environment, blue, serves production while a separate environment, green, holds the next release. You validate green before directing production traffic to it. The defining action is a traffic handover between environments.
A reverse proxy represents backend servers to their clients. The client connects to the proxy, and the proxy communicates with a backend on its behalf. Client-to-proxy and proxy-to-backend connections are separate, so a backend can change without requiring a new client-facing endpoint.
Opening a database connection takes work: establishing a network connection, authenticating, and creating a database session. A connection pool keeps connections available for reuse. A request borrows one, uses it, and returns it; the connection can outlive the request.
Connection pooling keeps connections available for reuse. Instead of opening a database connection for every operation, application code borrows an existing connection and returns it afterward. The connection outlives any one operation.
Service Quotas helps you discover supported AWS quotas, inspect their values, and request supported increases. A quota limits resources, throughput, or operations—for example, EC2 On-Demand vCPUs or Lambda concurrent executions. Quota headroom is the allowance remaining between relevant usage and the applied limit, measured in the same units and scope.
A standby Region must support the workload required during recovery, not just its small normal workload. Start with the failover demand: traffic transferred from the failed Region plus traffic the destination already serves. State the required throughput and latency, then use representative load tests to translate that demand into resources. If reduced service is acceptable during recovery, make that an explicit requirement.
Exponential backoff increases the wait between retries after a failure. Use it for failures that may clear without changing the request, such as throttling, selected server errors, or connection failures. Follow the API's documented retry rules and server guidance such as Retry-After. Invalid parameters and permission errors normally need correction, not repetition.
Data durability means preserving data against permanent loss. Storage systems use redundant copies or erasure coding, which distributes enough data and recovery information to reconstruct lost pieces. Integrity checks detect damage, and repair restores redundancy while enough healthy data remains.
Data durability asks whether stored data will survive rather than be permanently lost. High availability asks whether users can successfully use a service when they need it. These are independent design objectives: meeting one does not establish that the other is met.
Replication maintains copies of data and propagates changes between them. To choose a replication configuration, first identify the failure boundary: the resources that one failure can make unavailable together. Separate devices can survive an individual device failure, but copies inside one Availability Zone still share that zone's failure boundary.
Data replication maintains multiple copies of data by propagating changes between them. The copies follow the changing data rather than remaining fixed snapshots. Keeping another copy gives a storage system a way to preserve data when one copy is lost.
Amazon CloudWatch metrics are time-ordered measurements. Start with what the workload must deliver: successful requests, acceptable response times, and enough capacity. Monitor request failures and latency for customer impact, then resource utilization for capacity pressure. Low CPU alone does not prove that an application is available.
Distributed tracing follows a request across application boundaries. An order service can respond slowly because it is waiting for inventory, even when the order service itself has no resource problem. A trace connects the operations involved in that particular request rather than showing each service in isolation.
AWS X-Ray helps you understand a request that crosses application boundaries. A trace brings together the recorded work for that request. A segment describes a service's work, while a subsegment describes a smaller operation, such as an outgoing database call.
CloudWatch metrics are numerical measurements over time, such as request counts, error rates, and latency. They help answer: “Is the workload unhealthy, and how widespread is the change?” Even a latency percentile does not describe the path of an individual request.
Infrastructure as code (IaC) stores infrastructure definitions in files that a deployment tool can use. In a declarative definition, you describe the desired state, such as a database configuration or a security group's allowed connections, rather than listing every API operation needed to create it.
Configuration drift is a mismatch between the intended configuration and what actually exists. A resource can keep working while drifting: an administrator might open an access rule for troubleshooting and forget to restore it. Availability alone does not show that configuration is correct.
AWS CloudFormation uses a JSON or YAML template to describe AWS resources, their properties, and their relationships. A stack is the collection of resources CloudFormation manages from that template. CloudFormation works out dependency ordering, rather than requiring you to create each resource manually.
High availability means keeping a service usable for its required proportion of time. It can permit brief interruptions while the system recovers. Fault tolerance requires continued operation through specified failures, without interrupting the operation being protected.
A single point of failure is something whose failure can stop the service because every usable request path depends on it. Two application servers do not remove that risk if both require one network appliance or one database. Follow the whole request path and ask whether a working alternative remains when each required component fails.
Health-driven recovery connects three jobs: detect an unhealthy application target, stop selecting it for traffic, and replace it automatically. These jobs can run outside the application, so a suitable existing application does not need new recovery logic in its code.
An application replica is replaceable only if another replica can obtain the state needed to continue serving users. State includes login sessions, uploaded files, and database records. Starting the same application image does not recreate a shopping cart held only in the failed process's memory.
A useful availability KPI answers a business question: can customers complete checkout when they need to? Define the journey and what counts as success before choosing a measurement. For example, a successful checkout attempt must confirm an order within five seconds; a healthy server alone does not prove checkout is available.
A Service Level Indicator (SLI) measures service behavior that matters to users. Translate a business requirement such as “customers must be able to place orders quickly” into an observable operation: a customer submits a checkout and receives confirmation that the order was saved. Measure that outcome, not simply whether the machines are running.
A Key Performance Indicator (KPI) is a selected measurement used to judge progress toward an important objective and support a decision. For an online store, revenue per customer could help leaders decide where to invest. A measurement does not become a KPI just because it is available on a dashboard.
A service level objective (SLO) defines acceptable service through a measurement, a target, and an evaluation window. Start by identifying the user task and the consequences when it fails: lost sales, delayed work, missed deadlines, or harm. Different tasks within the same application can justify different reliability targets.
A Service Level Indicator (SLI) measures service behavior. For example, a checkout success SLI measures successful eligible checkout attempts divided by all eligible checkout attempts. A reported value of 99.8% describes what happened; it does not say whether that was good enough.
Determine high-performing and/or scalable storage solutions1 free11 lessons
Hybrid cloud storage connects local applications to cloud-backed data through a coordinated storage system. A local gateway provides a familiar access interface, while cloud storage holds a dataset that can be larger than the local disks.
AWS Storage Gateway gives applications familiar storage interfaces while using AWS for cloud storage. A gateway appliance near the applications supplies local storage and transfers data to AWS. Local access does not mean every byte is always local.
AWS DataSync copies files and objects between supported storage systems. Common endpoints include NFS and SMB shares, object storage, Amazon S3, Amazon EFS, and supported Amazon FSx file systems. Use it for an initial migration or repeated copies of changing data.
AWS DataSync moves data between supported storage systems. Choose it when the result you need is a copy at a destination: for example, migrating an existing file collection to AWS or periodically copying changed files. Applications access the source or destination storage, not a file share served by DataSync.
The S3 Glacier storage classes reduce storage costs for data that is kept for a long time and read infrequently. Start with the access requirement: must an application read an object immediately, or can it wait for a restore? Lower storage cost is useful only when the retrieval behavior still meets the application's needs.
IOPS means input/output operations per second: how many reads and writes a storage system completes each second. Storage throughput measures the amount of data transferred each second, commonly in MiB/s. These describe the same activity in two different ways.
IOPS is the number of read and write operations completed each second. For sizing, the useful requirement is the operation rate needed during representative busy periods, at an acceptable latency. A daily average can hide the busiest minutes that storage must support.
Sustained throughput is useful work completed per unit of time over the interval that matters. Choose a measurement boundary: records committed to destination storage, for example, rather than records submitted by a producer. Retries and failed submissions are not additional completed work.
Throughput measures work completed per unit of time, such as records per second or bytes per second. Latency measures elapsed time for an individual record or operation. A system can complete many records each second without completing any particular record quickly.
Start with the access pattern: random or sequential access, small or large requests, reads or writes, and how many requests run concurrently. Small random database reads often demand many operations; large sequential scans often demand many bytes per second. Also record whether the application needs block devices, shared files, or objects.
Storage capacity is the amount of data you can retain, measured in bytes. Start with current usage and choose a planning horizon, such as eight months. For roughly constant growth, use projected retained bytes = current bytes + net growth per month × months. Net growth means additions minus deletions. When growth accelerates or retention rules change, project each period separately rather than extending an old average.
Design high-performing and elastic compute solutions15 lessons
Amazon EMR provides managed environments for distributed data frameworks, including Apache Spark and Hadoop. You supply processing code and configuration; the framework divides the work across compute resources. Common uses include transforming large datasets, joining records, and producing aggregates.
Amazon EMR and AWS Glue both process and transform data at scale. The useful distinction is not “large data versus small data” or “Spark versus no Spark.” Both can run distributed Apache Spark processing, which divides work across multiple compute resources.
Data locality means placing compute near the data it uses, or placing frequently read data near its consumers. Start by identifying where data originates, where it is stored, and which applications read or write it. Record both the volume moved and how often the movement happens.
AWS Wavelength places supported AWS compute and storage infrastructure in telecommunications partners’ locations. An application handler running there can serve users on the connected mobile network without sending every interaction to a regional data center.
AWS Local Zones and AWS Wavelength both let you place application compute closer to users than a distant AWS Region. Their important difference is what makes the placement close: a Local Zone serves a nearby geographic area, while a Wavelength Zone places AWS infrastructure inside a telecommunications partner’s network.
AWS Wavelength places AWS compute and storage infrastructure within telecommunications partners’ networks. You can run an application on Amazon EC2 in a Wavelength Zone so that connected mobile devices reach its processing logic over a shorter network path.
An AWS Auto Scaling scaling plan brings scaling settings for supported application resources into one place. You can discover resources through an AWS CloudFormation stack or resource tags, then configure how the selected resources should scale.
For an on-demand AWS Lambda function, memory allocation is both a memory limit and a performance setting. Lambda allocates CPU capacity in proportion to configured memory. Increasing memory therefore gives the function more CPU capacity, even when its code does not need more space for data.
AWS Fargate provisions capacity for each ECS task or EKS pod from its resource configuration, not from its moment-to-moment CPU activity. Compute charges reflect the provisioned vCPU and memory over the billable duration. An idle application does not receive a smaller compute bill just because it uses little of its allocation.
Resource utilization describes how much capacity a workload uses, separately for CPU, memory, storage, and networking. A low CPU reading does not mean the whole instance is underused: memory or network capacity may already be limiting performance. Start with a representative workload cycle, including normal traffic, busy periods, and scheduled jobs.
CPU architecture describes the processor execution target that software must support. On Amazon EC2, two important targets are x86-64 and Arm64. The operating-system image, executable binaries, native libraries, and software agents must support the selected architecture.
An EC2 instance family describes a resource profile: the balance of CPU, memory, storage, networking, and sometimes accelerators. Choose a profile that addresses the workload's limiting resource. Adding CPUs to a workload that is waiting for memory or storage can leave those CPUs idle.
An EC2 instance size sets resource allocations within an instance family, including vCPUs and memory. Network and storage performance can also vary by size. Start with a compatible instance family, then choose the smallest size that meets the workload's performance needs with justified headroom: spare capacity for expected variation and growth.
Right-sizing means choosing compute resources that meet performance requirements without unnecessary capacity. Start with a representative baseline: measurements covering normal activity, busy periods, recurring batch jobs, and relevant seasonal peaks. A quiet afternoon or a long-term average can hide the demand that determines the required size.
AWS Compute Optimizer analyzes resource configuration and historical utilization to recommend better-sized resources. After you opt in and sufficient utilization data is available, it can recommend EC2 instance types and Lambda memory settings. A recommendation is a candidate configuration, not proof that a change will meet your application's requirements.
Determine high-performing database solutions18 lessons
An index is an alternative access path to data. Instead of inspecting every row, a database can search index entries and retrieve matching records. This lesson uses conventional B-tree indexes in relational databases, such as supported engines in Amazon RDS and Amazon Aurora; other index types have different capabilities.
Denormalization deliberately combines related data or stores redundant values to reduce retrieval work. A normalized model keeps related entities separate to reduce duplication and update anomalies. For example, an order can reference a customer record, but displaying both may require a join or another lookup.
Sharding divides records across independently managed database resources. Each shard owns a different subset, allowing storage and writes to grow beyond one database writer. Start with access patterns: which records are read together, which are updated together, and which operations dominate traffic?
Database capacity starts with the requests the database must serve, not just the amount of data it stores. Measure reads and writes per second, item or result sizes, query complexity, and concurrent requests. Include busy periods and overlapping batch work: the same daily request count can arrive steadily or in a short, demanding burst.
Connection multiplexing separates a client connection from a physical database connection. Applications connect to a proxy endpoint. The proxy maintains backend connections to the database and assigns a suitable one when a client has work to execute.
Amazon Aurora is a managed relational database engine with two editions: Aurora MySQL and Aurora PostgreSQL. Choose the edition that matches the application's SQL dialect and database ecosystem. One database does not accept both dialects interchangeably.
A database engine is the database software that stores data and processes queries, such as PostgreSQL, MySQL, or Oracle Database. A homogeneous migration keeps the same engine. A heterogeneous migration changes to a different engine.
A same-engine destination reduces conversion work, but it does not prove that the application will behave the same way. PostgreSQL on one server and PostgreSQL on another can differ in version, installed extensions, settings, and permissions. Assess the exact destination configuration, not just its engine name.
A target engine is suitable when it can preserve the application's required behavior and offer worthwhile benefits after conversion. Start by identifying source-engine dependencies: features or assumptions that tie the workload to its current engine. A database with simple tables and portable SQL usually needs less conversion than one whose business rules live in engine-specific stored procedures.
AWS Database Migration Service (AWS DMS) moves data between supported source and target databases. A homogeneous migration keeps the same database engine, such as PostgreSQL to PostgreSQL. A heterogeneous migration changes engines, such as Oracle to PostgreSQL.
A database contains both data, such as customer rows, and schema and code, such as table definitions, views, and stored procedures. Moving the rows and making their surrounding structures work on the target are different jobs.
An access pattern describes how an application retrieves or changes data: which records it needs, how it finds them, and what it returns. Write down concrete operations such as “get a cart by customer ID” or “join orders with customers using different filters.” Choose a database model around these operations, not just around the shape of a sample record.
A relational schema defines tables, columns, data types, keys, and constraints. Design tables around the things your application records and their relationships. For a shop, Customers stores customer facts, Orders stores order facts, and OrderItems stores the products and quantities within each order. This logical organization is separate from the servers and storage running the database.
An in-memory database keeps its working data in RAM for normal operations, rather than fetching that data from disk. This supports low response times and high request rates, especially for small, predictable operations such as session lookups, counters, and leaderboard updates.
Amazon Aurora Serverless v2 automatically adjusts database compute as application demand changes. Applications still connect to a database endpoint and run SQL using an Aurora MySQL-compatible or Aurora PostgreSQL-compatible engine. Serverless describes how compute is managed, not a different database model.
A transaction is a logical unit of database work that either commits or aborts. For a transfer between accounts, the debit and credit belong inside the same transaction boundary. Begin the transaction, perform both changes, and commit only after the whole operation succeeds. With autocommit enabled, separate statements normally commit separately unless you explicitly group them.
A slow database does not always need more servers. First identify whether time is spent scanning records, repeating the same reads, serving many different reads, or processing writes. Check query plans and workload measurements before choosing a scaling technique.
A database is the source of truth; a cache holds reusable copies. Before choosing a policy, define acceptable staleness: how long the application can safely use an outdated value. A product description can often tolerate some delay. A decision that grants permission or reserves inventory may need an authoritative database check.
Determine high-performing and/or scalable network architectures15 lessons
A tier is a separately deployed part of an application, not just a folder of code. In this lesson, web servers handle presentation, application servers run business rules, and a database stores persistent data. Separate deployment lets you control access and capacity for each responsibility.
An AWS Site-to-Site VPN connection includes two IPsec tunnels. Each tunnel has its own bandwidth limit; the connection is not one unlimited pipe. Check the current limit for the tunnel option you plan to use rather than assuming every VPN tunnel has the same capacity.
Sizing AWS Direct Connect means choosing enough bandwidth for your traffic without buying excessive unused capacity. A dedicated connection provides a physical AWS port assigned to one customer at a Direct Connect location. You request it through AWS; a carrier can still provide the path from your premises to that location.
A hub-and-spoke topology can give application networks access to shared services without letting those applications reach one another. Here, Production and Development each attach to AWS Transit Gateway, the routing hub. Shared services occupy a third VPC, and all three VPC address ranges are nonoverlapping.
Network peering connects two networks directly while keeping them separate networks. With AWS VPC peering, workloads in the paired VPCs can communicate using private IP addresses. Each peering connection provides connectivity for that pair, not a shared router for other VPCs.
AWS Transit Gateway is a regional routing hub. An attachment connects a network or connection to that hub: a VPC attachment connects a VPC, a VPN attachment connects a Site-to-Site VPN, and a peering attachment connects another transit gateway.
A hub-and-spoke topology lets several networks share a transit hub. Sharing simplifies connections, but performance and cost depend on the path each flow actually takes—not how tidy the topology looks.
Active-active means multiple environments serve production traffic at the same time. For protection against a regional disruption, those environments must span Regions, not just Availability Zones. Their traffic shares do not have to be equal.
Classless Inter-Domain Routing (CIDR) describes an address block using an address and a prefix length, such as 10.20.0.0/24. An IPv4 address has 32 bits. The /24 prefix fixes the first 24 bits, leaving 8 bits to vary within the block.
IPv4 uses 32-bit addresses; IPv6 uses 128-bit addresses. The much larger IPv6 address space gives growing networks room for many subnets and endpoints, reducing the need to conserve addresses through network address translation. It does not remove the need to plan prefixes, routes, and security boundaries.
Network headroom is capacity deliberately left available for growth, traffic peaks, and temporary overlap. Start with address demand in each subnet, not just the VPC total. Count private IP allocations, not simply servers: network interfaces, container networking, load balancers, and interface endpoints can also consume addresses. Use the allocation behavior of the services you actually deploy.
AWS Outposts places AWS-managed infrastructure in your facility. Supported Amazon EC2 workloads run locally, using familiar AWS APIs and tools. This is useful when processing must stay close to local systems for low latency or when specified application data must remain on premises.
AWS Local Zones place selected AWS infrastructure near a geographic area, helping applications serve nearby users with lower network latency. Place the latency-sensitive portion of an application there, rather than assuming the whole application must move.
Content-based routing selects a destination by examining attributes of a request. For HTTP applications, an Application Load Balancer can use host, path, and HTTP header conditions in its listener rules.
Latency-based routing chooses a regional endpoint using expected network delay. It suits an application available in multiple Regions whose endpoints can serve the same application name. Its goal is better responsiveness, not equal traffic distribution or selection of the geographically closest Region.
Determine high-performing data ingestion and transformation solutions48 lessons
Amazon Athena is a serverless query service: you submit SQL, and AWS manages the compute that executes it. For S3 queries, the source data stays in Amazon S3; you do not first load it into a database.
Amazon Redshift is a managed data warehouse for SQL analytics over large datasets. Analytical queries often calculate totals, averages, or grouped results across many rows while using only a few columns. Redshift's columnar storage makes that access pattern efficient.
Amazon Athena is a serverless query service for running SQL directly against data in Amazon S3. It is a natural starting point for ad hoc analysis: questions asked as needed, such as investigating an unexpected change in application logs. You define tables describing the files and their locations, grant access, and query without first loading the data into a warehouse.
Time-series telemetry records how something changes over time. A temperature reading, for example, has a timestamp, a measured value, and identifying attributes such as device and location. Queries often select a time window, filter a device group, and calculate an average, peak, or trend.
Amazon QuickSight is a managed business intelligence service for exploring data and sharing interactive dashboards. An author connects a data source, creates a dataset, and prepares fields, data types, and calculations for reporting.
Amazon Managed Grafana is the usual choice for operational observability: understanding the health and behavior of applications and infrastructure. Its dashboards help operators answer questions such as “When did latency increase?” and “Which service is showing errors?” AWS manages the Grafana infrastructure so teams can focus on monitoring rather than running Grafana servers.
Batch processing works on a bounded set of inputs: a set with a defined end. An input window determines which records belong to that batch. It might cover one hour of source records, yesterday's transactions, or a fixed collection of uploaded files.
An event records something that happened, such as a payment failing or a server reporting its status. A producer continuously publishes these records to a stream as they become available.
Event streaming treats incoming events as a continuous flow. Producers publish records as events occur, and consumers process the flow without waiting for the entire input to be complete. The source can keep producing events indefinitely.
Change Data Capture (CDC) identifies changes made to source data, such as inserts, updates, and deletes. It answers: Which source changes are captured for downstream use? A pipeline can capture changes to selected tables rather than repeatedly extracting every row.
Incremental loading processes changes instead of repeatedly loading the complete source. A pipeline commonly begins with a full load, then processes new rows, updates, or deletion events in later batches. Running hourly or nightly still counts as incremental loading; it does not require streaming.
An offline import moves data onto a physical Snow device at your site, then ships that device to AWS for import into Amazon S3. Copying finishes before the data reaches S3: delivery, local preparation, return shipment, and AWS ingestion all contribute to the schedule. Confirm current device availability, customer eligibility, and lifecycle restrictions before committing to a migration plan.
AWS DataSync moves files and objects between supported storage systems over a network, using internet connectivity or AWS Direct Connect. AWS Snow Family offline imports move the bulk data on physical devices: copy locally, return the devices, and wait for AWS to import the data into Amazon S3. Offline describes how the bulk data travels, not an absence of local networking or management work.
Extract, Transform, Load (ETL) reads source data, prepares it, and writes the prepared results to a destination. Transformation includes cleaning values, standardizing formats, joining datasets, and calculating summaries. These responsibilities can run in a scheduled job, a continuously running processor, or code invoked by an event.
AWS Glue ETL jobs prepare data using managed compute. For a Spark ETL job, you configure processing capacity and job logic without managing a cluster of servers. A common pipeline reads CSV files, cleans their records, and writes Parquet files for analytics.
Amazon AppFlow is a managed integration service for transferring data between supported SaaS applications and AWS services. You configure a flow: its connections, the data to transfer, and supported built-in transformations. When those capabilities meet the requirement, you avoid building and maintaining a custom transfer application.
A freshness target states how soon data must become usable. Define both ends: for this lesson, time starts when an event occurs at its source and ends when its transformed record can be read from the destination. An ingestion acknowledgment is only an intermediate milestone.
Amazon Kinesis Data Streams holds a continuing sequence of records so applications can process events as they arrive. A producer writes records; a consumer reads and processes them. Reading a record does not delete it.
Amazon Data Firehose, formerly Amazon Kinesis Data Firehose, is a managed delivery service. You create a delivery stream with a source configuration and a destination; Firehose handles buffering and delivery without a fleet of delivery workers for you to operate.
Amazon Kinesis Data Firehose, now named Amazon Data Firehose, is for managed delivery to supported destinations such as Amazon S3. Producers send records, and Firehose handles destination delivery. Choose it when the main goal is to land incoming data without building and operating a destination-writing consumer.
Amazon Data Firehose, formerly called Amazon Kinesis Data Firehose, can convert incoming JSON records into Apache Parquet or Apache ORC before delivering them to Amazon S3. This is a built-in conversion feature, not a Lambda function you must write.
Amazon Managed Service for Apache Flink runs Flink applications that continuously consume events and update results. AWS manages the underlying infrastructure; you define the processing logic, connectors, state, and time behavior.
Amazon Managed Service for Apache Flink runs applications that continuously compute over streams. Choose it when a result depends on relationships between events, such as a running total, a time-windowed count, or a join between streams.
Amazon MSK runs managed Apache Kafka clusters. A producer uses Kafka APIs to publish records to a named topic, such as orders. A topic is a stored stream of records, not a destination that removes a record when someone reads it.
Amazon MSK runs managed Apache Kafka. Amazon Kinesis Data Streams provides streaming through AWS-specific APIs. Both support retained records, replay, and independent consumers, so those needs alone do not distinguish them. The first useful question is whether your applications must speak Kafka.
Amazon Kinesis Video Streams receives video from device producers and makes it available to playback and analytics applications. A producer sends encoded media as timestamped fragments: chunks of media that the service can index and retrieve. With retention enabled, consumers can read stored video as well as follow incoming video.
Amazon Kinesis Video Streams is designed to ingest and retrieve time-based media. Choose it when applications need video from devices, access to retained footage, or media playback. It handles video as timestamped media fragments rather than unrelated application records.
A data lake separates durable storage from the compute that processes it. Amazon S3 stores objects such as database exports, JSON events, and images; processing and query services use those objects without moving everything into one database first.
Schema on read means applying a structure when a job reads stored data. A CSV file contains text fields, not built-in integer or decimal types. An explicit schema tells the reader which columns to produce and how to interpret their values, rather than relying on type inference.
Per-entity ordering means preserving the sequence for one order, account, or device—not forcing every event into one global sequence. An order-created event must precede cancellation for that order; unrelated orders can progress independently.
A checkpoint records enough progress to resume a stream consumer after failure. For stateful processing, it must keep source positions consistent with saved state, such as running totals. Saving a later position with an earlier total would skip updates during recovery. Partitioned streams need positions for each partition; in Kinesis Data Streams, these are tracked per shard.
A successful transfer message does not, by itself, prove that the stored destination data matches the source. A checksum is a value calculated from data bytes. Calculate it at the source, then independently calculate it from the destination data using the same algorithm. Different values mean the compared content differs.
Incremental transfer starts with a baseline: an initial copy of the data you need. Later transfers move new or changed data instead of repeatedly copying everything. A recurring full transfer, by contrast, includes unchanged data again.
Parallel processing transfers independent pieces of data at the same time. A partition is one piece of work, such as a file, a group of files, or a database key range. The partitions should cover the intended dataset without accidental gaps or overlaps, and each must be transferable without waiting for another partition to finish.
AWS DataSync charges for moving data, but its service fee is only one part of a transfer's total cost. Start by checking which task mode supports your source and destination, then estimate that mode's charges using current AWS pricing.
Amazon Managed Grafana provides managed Grafana workspaces for visualizing operational data. A dashboard contains panels such as time-series charts, gauges, and tables. Each panel uses queries to retrieve data from a connected data source.
A dashboard may request the same sales total many times. In-memory caching keeps a reusable query result in RAM, so later requests can avoid running the database query again. Here, a dashboard application on Amazon EC2 uses Amazon ElastiCache as a shared cache and Amazon RDS as its authoritative data source.
A sales dashboard may repeatedly calculate the same daily regional totals from detailed transactions. With query-time aggregation, each query performs that grouping and calculation. With precomputation, a refresh job calculates the totals ahead of demand and stores them for repeated use. These stored results are materialized aggregates; saving a query definition alone does not store its results.
In-memory caching retains values in RAM so later requests can reuse them. For a dashboard, retaining a calculated sales total can avoid repeating the same database query or calculation. Caching answers: Can we reuse a result we already have?
Row-level security (RLS) controls which records a viewer may access. Sharing a dashboard grants access to the dashboard; RLS determines which rows contribute to that viewer's results. Two managers can open the same sales dashboard and see different records and totals.
Distributed processing splits work across networked machines. Before choosing compute, ask whether each task can finish using only its own input. Resizing separate images is independent work: one task does not need another task’s intermediate result. Many workers can increase throughput without exchanging data with each other.
Batching collects several records before sending or processing them together. Each request has overhead, such as connection handling, authentication, and response processing. Sharing that overhead across records can improve throughput and reduce cost per record, at the expense of some waiting.
A partition key determines which subset receives each record. Start with frequent query filters, not the field with the most distinct values. If reports usually read events for a particular date, event_date is a useful candidate. If they also consistently filter by region, region may be worth adding—but only if each resulting group contains enough data.
Backpressure is feedback that makes upstream activity respond to downstream capacity. If a destination cannot keep up, its consumer reduces concurrent work, delays new requests, or pauses reading. The aim is to protect the pipeline from overload, not to process every arrival immediately.
CSV parsing recovers field boundaries from text. Agree on the character encoding, delimiter, quote character, escape convention, and whether a header is present. Decode using the agreed encoding, such as UTF-8, rather than relying on reader defaults.
Apache Parquet is a file format, not a database or query engine. A writer takes records with a schema, which describes fields and their types, and writes their values into a structured file. For example, an event date should be represented as a date and an amount as an appropriate numeric type.
Comma-Separated Values (CSV) represents flat tables as text records with comma-separated fields. Many spreadsheets, databases, and libraries can exchange it, and people can inspect it with a text editor. This makes CSV useful when a receiving system needs flat-text interchange. Producers and consumers still need to agree on how to interpret the fields.
Data compression reduces the bytes needed to represent information. For structured records, lossless compression preserves the original data exactly: decompressing a gzip-compressed CSV file restores its original CSV bytes. Compression effectiveness depends on the input; a smaller result is not guaranteed for every file.
Design cost-optimized storage solutions1 free28 lessons
Upload granularity means how much data you put in each object. Uploading 100 small files as separate objects with one PutObject request each makes 100 PUT requests. Combining those files into one archive and uploading it with one PutObject makes one PUT request, assuming no retries.
Consolidated billing in AWS Organizations makes the management account responsible for paying the organization's consolidated AWS charges, including charges incurred by member accounts. It is available with both the consolidated-billing-only and all-features options.
Cost allocation connects AWS spending to the workloads and people responsible for it. With AWS Organizations consolidated billing, the management account pays the charges for the organization's member accounts. Consolidation brings charges together without removing their account attribution.
Resource tagging describes resources using key-value metadata, such as Application=Payments. Cost allocation assigns expenses to products, teams, or other business owners. A tag can supply evidence for that assignment, but describing a resource and attributing its costs are different jobs.
Cost allocation decides which team, product, or department owns a cost. With AWS Organizations consolidated billing, the management account is responsible for paying member-account charges. That payment responsibility does not make every expense a management-team expense.
A cost allocation tag lets you organize eligible AWS charges by a business label, such as department or cost center. Start with a resource tag: a key such as CostCenter and a value such as CC104. The key becomes a billing dimension after activation and processing; its values identify the categories within that dimension.
Cost allocation tags let you group applicable costs by a tag key and its values. For application and team reporting, choose user-defined keys such as Application and Team. Consistent values let an application’s supported compute, database, and storage costs appear under the same application name.
AWS Cost Explorer provides interactive reports of historical cost and usage. A useful report starts with a question: did spending grow, which service contributed, or which team owns the cost? The cost metric determines what the money shown in the chart means.
AWS Cost Explorer forecasts future spending from historical cost and usage data. Its forecasting models use patterns in that history to estimate what spending could look like ahead. A forecast is therefore a projection, not a bill already incurred or a spending limit.
AWS Budgets monitors a defined measure against a target. A useful budget definition answers four questions: what to measure, over which period, against what amount, and for which portion of your AWS activity. Start with the budget type, because it determines the meaning and units of the target.
AWS Budgets compares monitored costs with configured thresholds. An actual threshold checks costs already recorded for the budget period. A forecasted threshold checks the estimated total cost by the end of that period, based on available spending history.
AWS Budgets monitors spending against a target you define. Choose it for questions such as “Are we staying within our monthly spending target?” or “Can the owner be notified when spending crosses a budget threshold?” The target gives the monitoring a financial reference point.
The AWS Cost and Usage Report (CUR) exports detailed billing and usage data to Amazon S3. Its settings determine which details your analysis can use later. Start with two independent choices: time granularity and resource IDs.
The AWS Cost and Usage Report (CUR) contains detailed billing records called line items. A row describes a charge, usage, or adjustment for a particular interval and set of billing attributes. One resource can appear in many rows, so counting rows does not tell you how many resources exist.
AWS Cost Explorer provides interactive views of AWS costs and usage. Use it to explore spending, compare periods, and identify which services or accounts contributed to a change. You can adjust the view without first building a billing-data analysis system.
Storage tiering matches data to a storage class whose access behavior and charges suit the workload. Start with two separate questions: how often will the data be read, and how quickly must it be available when requested? Rarely read data can still have an urgent retrieval deadline.
An archive lifecycle defines what happens to information after routine use ends. First identify the data's owner, required retention period, and acceptable retrieval time. These determine when it can move to cheaper storage and when deletion is permitted. Inactive does not mean disposable.
Storage tiering asks, “Where should this data live to meet its access needs economically?” It matches data to storage classes based on how often it is accessed and how quickly it must be available. Tiering can apply to active application data as well as inactive records.
S3 Lifecycle automates storage-class changes using rules you configure. An age-based transition happens when an eligible object reaches a specified age, even if someone read it yesterday. Reading an object does not restart its lifecycle clock.
Sequential I/O reads or writes consecutive logical storage locations: each request continues where the previous request ended. Random I/O reads or writes nonconsecutive locations, jumping between separated parts of the address space. Both terms describe access order, and both apply to reads and writes.
For scattered reads and writes, storage capacity alone does not tell you whether an application will run well. Request size is the amount transferred by one operation. IOPS counts input/output operations per second, while throughput measures the data transferred per second. Small requests can consume many IOPS without moving much data.
For a large sequential transfer, the main goal is usually throughput: how much data moves each second. IOPS counts operations per second, while request size describes how much data each operation transfers. A high IOPS rating alone does not tell you how quickly a large file will finish transferring.
Retrieval latency is the wait between requesting stored data and that data becoming available to read. Define the boundary before comparing storage options: waiting for an archive restoration to finish is different from waiting for the first byte of an ordinary read request.
Lossless compression allows the original bytes to be recovered exactly. It is the normal choice for logs, transactions, and analytical records. Repetitive text often compresses well; encrypted data and already compressed media usually offer little additional reduction. Compression is not encryption and provides no confidentiality.
Storage capacity is the amount of data a resource can hold. Right-sizing starts with measured space usage, not the size already allocated. Include application data, indexes, logs, and other files stored on that resource; separately stored backups need their own capacity estimate.
Data egress means data leaving a boundary, not necessarily leaving AWS. Compare paths by recording the source, destination, direction, volume, and route. The diagram follows four independent outbound flows from one application; it omits return traffic and routing details that do not change this comparison.
An online transfer sends data over a network, using an existing internet connection or a dedicated connection such as AWS Direct Connect. An offline transfer moves the bulk data on physical media for import. Consider offline transfer when usable network capacity cannot move the data in time, but first confirm that a supported physical-transfer option is available for your location and account.
Total Cost of Ownership (TCO) is the complete cost of a solution over an agreed evaluation period. Before estimating storage costs, give every option the same time horizon and workload assumptions: initial data volume, growth, request frequency, data retrieved, and data transferred.
Design cost-optimized compute solutions16 lessons
Pay-as-you-go compute lets you pay for metered usage without a long-term usage commitment. For an Amazon EC2 On-Demand instance, the starting point is the time the instance runs, not the time its application does useful work. A running instance can incur compute charges even when its CPU is idle.
An EC2 purchasing option changes how you pay for compute, not what your application does. On-Demand Instances let you pay for compute usage without a long-term commitment. They are useful for short-lived work, unpredictable demand, and workloads you are still measuring. You do not receive a commitment-based discount, but you avoid paying for a long-term commitment you may not use.
No Upfront describes when you pay for a commitment, not whether you have one. With a no-upfront commitment offering, you make no initial commitment payment, but you accept recurring charges over the agreed term in exchange for discounted eligible usage.
Workload predictability is confidence in future compute requirements. Start with measured usage over representative business cycles, including quiet periods, busy periods, and seasonal changes. Amazon CloudWatch provides utilization metrics; billing and usage records help show what compute actually ran. A traffic forecast alone does not establish how much compute you need.
A commitment discount is a billing benefit, not an instruction to launch resources. Before choosing how much to commit, identify which usage can receive the benefit. Predictable usage outside the agreement’s eligibility rules cannot consume that commitment.
Savings Plans exchanges a spending commitment for discounted rates on eligible usage. You commit to a dollar amount per hour for a one-year or three-year term. AWS automatically applies the benefit to matching usage. This changes billing, not application performance, and does not reserve EC2 capacity.
Edge computing runs selected computations close to where data is produced or used. The location is relative to the workload: equipment-site processing is close to sensors, while distributed cloud infrastructure can be close to web users. Edge computing is an architectural choice, not one particular service.
Amazon ECS Anywhere lets Amazon ECS manage containers on customer-owned servers or virtual machines outside AWS. A host registered into an ECS cluster becomes an external instance. The ECS control plane stays in AWS; application containers run on your hardware.
Amazon EKS Anywhere provides software and tools to create and operate Kubernetes clusters on customer-managed infrastructure. In an on-premises deployment, both the control plane and the worker nodes run in your environment. The control plane manages cluster state and schedules workloads; worker nodes run application Pods.
AWS Outposts places AWS infrastructure at your site. AWS supplies, manages, and maintains the Outposts hardware, which connects to a parent AWS Region. You use supported AWS services locally when workloads need to stay close to local systems or data.
Both services let you run containers on infrastructure you manage, but they do not put orchestration in the same place. The control plane is the management layer that accepts workload definitions and decides where containers should run. The servers that execute those containers form the data plane.
Hybrid cloud connects public-cloud services with local infrastructure. Choose where each workload runs by following its users, data, and dependencies—not by assuming the whole application must run in one place.
A virtual machine (VM) runs its own guest operating system against a hardware interface supplied by a hypervisor. The guest sees processors, memory, disks, and network interfaces without needing to manage the physical server. Multiple VMs can share a server while remaining logically isolated.
A processor's instruction set architecture defines the instructions software can execute. On Amazon EC2, common targets are x86-64, used by Intel and AMD processors, and Arm64, used by AWS Graviton processors. Before comparing performance, check that the entire software stack supports the target.
The OSI model describes communication using seven conceptual layers. For forwarding decisions, ask which information a component uses. Layer 3 uses IP addressing; Layer 4 adds transport information such as TCP or UDP ports. These are responsibilities, not a requirement for seven separate devices.
Availability means that users can successfully use the service, not merely that its servers are running. Define the important user action first: signing in, submitting an order, or retrieving a report. A working home page does not establish availability if the required transaction fails.
Design cost-optimized database solutions7 lessons
Online transaction processing (OLTP) serves many short operations that read or change small amounts of data. Looking up an order, reserving inventory, and recording a payment are transactional work. Predictable response times matter, and related changes may need an atomic transaction: either all changes succeed or none do.
Columnar storage groups values by field. Parquet stores records in row groups, with separate column chunks inside each group; ORC uses a similar column-oriented organization. For a report that totals sales by region, a compatible reader can read region and amount without reading addresses or product descriptions.
Time-series measurements usually contain a timestamp, a measured value, and dimensions such as device or building identifiers. Storage selection starts with two questions: how quickly must observations be accepted, and how much history must remain available? A timestamp alone does not justify a specialized database.
Time-series data consists of observations indexed by time, such as device temperature readings. A record usually includes a timestamp, a measured value, and dimensions that identify its source, such as a device ID. Readings can arrive regularly or irregularly.
Time-series data records how something changes over time: a timestamp, a measurement, and identifying attributes such as device or location. Storage demand grows with arrival rate, record size, and retention. Query demand depends on how much history each request reads and how often requests run. A dashboard repeatedly reading recent measurements has different economics from an occasional report reading years of history.
AWS Schema Conversion Tool (AWS SCT) is a desktop application that helps translate database definitions between supported database engines. Compatibility depends on the source-to-target pair: a feature that translates to one target engine may need rewriting for another. Check support for the database engines and versions before starting.
Change Data Capture (CDC) captures inserts, updates, and deletes so a target can follow a source database. The initial snapshot supplies existing rows; the change stream supplies what changes afterward. They must share a coordinated source position so writes made during copying are not missed.
Design cost-optimized network architectures13 lessons
A NAT gateway is managed by AWS; a NAT instance is an EC2 instance that you configure to perform translation. Both can provide outbound IPv4 access for private workloads. Compare them over the same period, for the same traffic and availability requirements—not just by their advertised hourly prices.
A leased line is a carrier circuit with contracted capacity and service terms. Its recurring rental pays for the circuit to be available, even when it carries no traffic. Committed capacity does not necessarily mean every fiber or carrier device is exclusive to you.
A VPN tunnel carries protected traffic across an underlying network; it does not create extra bandwidth. For an internet-based VPN, available capacity depends on the internet access links and the path between the endpoints. Congestion, packet loss, and latency can reduce application performance even while the tunnel remains connected.
VPC peering connects two VPCs so their workloads can communicate using private IP addresses. It preserves their separate administration and can connect VPCs across accounts or Regions. It supplies network connectivity, not automatic permission to use an application.
DNS separates a resource's name from its network address. For https://app.example.com/orders, DNS resolves app.example.com, not the HTTPS scheme or the path. The application then connects to an address from the answer.
Longest prefix match selects the most specific destination prefix that matches a packet's destination IP address. The number after the slash counts the leading bits that must match. A matching /24 describes a smaller address range than a matching /16, so the /24 wins.
AWS Global Accelerator adds a paid acceleration layer to an application's network path. To estimate its traffic cost, separate three items: accelerator-hour charges, the data transfer premium, and the endpoint's applicable data transfer charges.
Time to Live (TTL) defines a lifetime, but a TTL value is meaningful only when you know what expires and how its deadline is calculated. In a cache, expiration normally ends permission to reuse an entry as fresh, without checking its source. It does not necessarily remove the stored bytes.
Throughput is the amount of work completed per second. For ingestion, measure both bytes per second and records per second over representative busy periods. An acceptable daily average can hide a short peak that causes throttling. Record size and uneven traffic across partitions can also limit ingestion.
A token bucket controls how much work reaches a downstream resource. It holds a limited supply of tokens, and each admitted request consumes tokens. Tokens are accounting units, not authentication credentials. In this lesson, each request costs one token.
Traffic shaping controls when packets leave an interface. When a bulk sender produces packets faster than the permitted departure rate, an egress queue temporarily holds them. Releasing those packets over time smooths the burst before it reaches a constrained link. Shaping changes departure timing; it does not increase the link’s capacity.
Traffic shaping controls when packets leave a queue. If a packet cannot be transmitted yet under the shaping policy, the shaper buffers it and releases it later. This smooths departures rather than passing every arriving burst straight through.
Equal-Cost Multipath Routing (ECMP) forwards traffic across multiple equally preferred routes to the same destination prefix. Here, cost means routing preference, not connection price. Routes need compatible routing attributes; two working tunnels do not automatically qualify.