CCNA Accelerate Workload Migration and Modernization Questions

The strangler fig pattern incrementally routes specific functions from the monolith to new microservices behind a facade, so each slice can be released and rolled back independently. This satisfies both the minimal-downtime and rollback constraints, unlike a single big-bang cutover.

Rehosting moves the application to AWS without altering its architecture, satisfying the minimal-refactoring constraint. The monolith runs on EC2 instances, gaining cloud benefits such as elasticity and pay-as-you-go pricing while avoiding code changes. This differs from replatforming, which requires modifying components, and refactoring, which demands architectural redesign.

Amazon Redshift is a petabyte-scale columnar data warehouse supporting SQL, stored procedures and ETL tooling, letting the company migrate with minimal refactoring while gaining managed cloud elasticity. It avoids the re-architecture effort required by serverless alternatives such as Athena.

ElastiCache stores session state in a managed Redis or Memcached cluster external to the application servers, so any instance can serve any user and sessions survive instance failure. This satisfies the stem's high availability requirement for a stateful application.

Amazon EC2 for Windows Server supports Windows authentication and COM+ components natively. By joining the instances to AWS Managed Microsoft AD, the application can use Active Directory for authentication without code changes. This approach provides a familiar environment for the legacy application and minimizes migration effort, aligning with a rehost strategy.

An ALB listener defines the port and protocol on which it accepts inbound connections, so creating one on port 8080 satisfies the requirement to accept TCP traffic there. The listener then evaluates rules and forwards to a target group. Without a matching listener, the ALB silently drops traffic, regardless of security group configuration.

AWS SCT analyses the SQL Server schema and automatically converts stored procedures, triggers and other proprietary objects into the target open-source engine's equivalent syntax. This satisfies the requirement to automate conversion, reducing the manual rewrite effort before data migration.

The Strangler Fig pattern incrementally replaces monolith functionality with microservices, routing traffic gradually to new services. This limits migration risk and avoids downtime, satisfying the six-month deadline with minimal disruption while enabling the serverless modernisation the company wants.

Network Load Balancer operates at Layer 4, forwarding TCP connections without inspecting or terminating them, so the proprietary binary protocol passes through unchanged. It satisfies the minimal-changes constraint and handles millions of requests per second, meeting the high-throughput requirement that an Application Load Balancer could not.

The strangler fig pattern involves gradually replacing parts of the monolith with microservices. AWS DMS can replicate data from the monolithic database to new microservice-specific databases, ensuring consistency during the transition. This allows incremental migration, reducing risk. DMS supports ongoing replication, so both systems can operate in parallel until the monolith is fully replaced.

AWS Application Migration Service replicates source servers block-level into AWS and launches them as EC2 instances, satisfying the migration-execution requirement. It also feeds replication status into Migration Hub, letting the company track progress across the VM fleet.

Continuous InnoDB redo log writes mean the source volume never reaches a quiescent state, so MGN's final sync cannot converge — each pass replicates new blocks faster than they drain. The 99% stall reflects this ongoing delta, not a network or staging-area fault. Quiescing the database or stopping writes lets the final cutover complete.

Amazon EFS provides a POSIX-compliant, shared NFSv4 file system that multiple EC2 instances can mount concurrently across Availability Zones, satisfying the simultaneous multi-instance access requirement. Unlike EBS, which attaches to a single instance, EFS is purpose-built for shared file workloads, making it the appropriate fit for this legacy application.

DMS performs continuous replication from the source Oracle database to RDS for Oracle, keeping the target synchronised until cutover. This satisfies the minimal-downtime constraint, since only a brief final switchover is needed rather than a full offline export and import of the 2 TB dataset.

Amazon SQS provides fully managed, durable queues that decouple producers from consumers, letting microservices communicate asynchronously without waiting on each other. This directly satisfies the resilience requirement: if a consumer fails or scales slowly, messages persist in the queue rather than being lost, absorbing traffic spikes.

Step Functions orchestrates the scheduled workflow, Lambda runs the processing logic serverlessly, and Amazon S3 stores the large input and output files. This combination removes server management and scales automatically, meeting the serverless and cost-reduction constraints.

Correct. A trust allows seamless coexistence and incremental migration.

KEY distribution co-locates matching join-column values on the same slice, so large-table joins execute locally without network redistribution. This directly targets the stem's complex joins across large tables, the dominant cost in Redshift query performance.

Running EC2 instances across two Availability Zones behind an Application Load Balancer removes the single hardware load balancer and provides high availability. An Auto Scaling group replaces failed instances automatically, which minimizes operational changes while satisfying the multi-AZ requirement for the compute tier.

Tape gateway presents a virtual tape library (VTL) over iSCSI to existing backup software. It stores virtual tapes in Amazon S3 and can archive them to Amazon S3 Glacier or Deep Archive. This eliminates physical tape management while preserving the backup workflow, matching the requirement exactly.

AWS Application Discovery Service collects data about on-premises servers, including network dependencies and process connections. It provides a dependency map that helps group servers into migration waves. This directly addresses the need to understand interdependencies and plan waves, making it the correct tool for this scenario.

Amazon SQS provides a fully managed queue that decouples producers from consumers, letting the order service enqueue messages while the notification service polls and processes them independently. This asynchronous, pull-based model satisfies the requirement to decouple the services and improve scalability.

Amazon SQS provides fully managed message queues that decouple microservices by buffering messages, so producers and consumers operate independently without waiting on each other. This directly satisfies the asynchronous communication requirement, unlike synchronous request-response services. It also removes the shared-database coupling by letting services exchange events through durable queues rather than direct calls.

Fargate's serverless compute model removes EC2 instance patching and cluster capacity management, satisfying the minimal-operational-overhead constraint. It runs containers inside the VPC with native IAM task roles and CloudWatch logging, integrating directly with the AWS services the stem requires.

Externalizing configuration into Parameter Store or Secrets Manager removes environment-specific values from the image, so the same image runs in every environment. Values can be injected as environment variables or mounted as files using the AWS Secrets and Configuration Provider for the Secrets Store CSI driver. This satisfies the requirement that the image must not be rebuilt per environment.

DMS change data capture continuously replicates ongoing changes from SQL Server to the target after the initial full load, keeping both synchronised. The cutover then needs only a brief application pause, satisfying the minimal-downtime requirement.

AWS Managed Microsoft AD provides the domain services and Kerberos-based Windows authentication the .NET application requires, while AWS handles patching, replication and domain controller availability. Rehosting on EC2 preserves the existing application without code changes, and the managed directory removes the operational overhead of self-managed AD.

Using full load plus ongoing replication (CDC) allows DMS to perform an initial data load and then continuously replicate changes from the source to the target. This minimizes downtime because the target remains synchronized until the cutover, at which point the application can be switched to the target with minimal interruption. It ensures data consistency by capturing all changes.

Rehosting on EC2 Windows preserves the existing Windows authentication mechanism without code changes, satisfying the minimise-changes constraint. Amazon RDS for SQL Server supports Windows authentication through AWS Managed Microsoft AD, allowing the application to connect using integrated security rather than SQL logins, so connection strings and authentication code remain largely unchanged.

Amazon RDS for SQL Server is a managed service that supports Multi-AZ deployments for high availability and automatic failover. It reduces operational overhead by handling backups, patching, and replication. Since the database cannot be modified, using RDS for SQL Server with Multi-AZ provides a compatible, scalable, and resilient database tier with minimal changes.

AWS Batch is a fully managed batch computing service that dynamically provisions compute resources based on job volume and requirements. It handles job scheduling, dependency management, and scaling, allowing the company to focus on rendering jobs. It integrates with Spot Instances for cost savings and can scale to handle spikes. This minimizes infrastructure management and aligns with pay-for-use pricing.

Amazon ElastiCache for Redis provides a fully managed, highly available Redis service that can be configured with cluster mode for scalability. By moving session state from local instances to ElastiCache, the application becomes stateless and can scale horizontally behind an Application Load Balancer. This requires minimal code changes because the application already uses Redis APIs, just pointing to a new endpoint.

Rehost moves the Windows Server and SQL Server workloads to Amazon EC2 essentially unchanged, satisfying the requirement to minimise application code changes. Unlike replatforming or refactoring, no engine swap or rewrite occurs, so the legacy application continues running on the same OS and database platform.

Apache DistCp is purpose-built for parallel, distributed copying between HDFS and Amazon S3, preserving data integrity across the large-scale Hadoop dataset. S3 provides eleven nines of durability with lower storage cost than HDFS on persistent EMR clusters, satisfying both the cost and durability constraints.

AWS Application Migration Service replicates the Windows server block-level to AWS, preserving the proprietary database unchanged, so no re-architecting occurs. Continuous replication keeps cutover downtime to minutes, satisfying both the minimise-downtime and avoid-re-architecting constraints. Replatforming or refactoring would alter the database engine, which the stem forbids.

Amazon EFS is a fully managed, scalable, elastic file system for Linux-based workloads. It supports POSIX permissions and can be mounted on multiple EC2 instances across multiple Availability Zones within a VPC. It provides high throughput and is designed for shared access, making it ideal for this scenario.

AWS Global Accelerator provisions two static anycast IPv4 addresses that external partners can whitelist, then forwards traffic to the ALB endpoint without exposing its dynamic node IPs. This satisfies the fixed-IP constraint while retaining ALB's layer 7 routing, and unlike CloudFront it preserves the client's source IP for partner-side filtering.

AWS Fargate provides serverless compute for containers, reducing operational overhead. Decomposing the application into microservices aligns with independent deployability and scalability. Giving each microservice its own DynamoDB table follows the database-per-service pattern, enabling each service to own its data. This combination meets all requirements with minimal management.

AWS Application Migration Service performs block-level replication of source servers into AWS, automating lift-and-shift for multiple machines with continuous replication that minimises cutover downtime. This satisfies both the rehost strategy and the unsupported proprietary database constraint, since the database travels with the server rather than needing RDS compatibility.

Amazon RDS for MySQL is a managed relational database service that is compatible with MySQL. It handles provisioning, patching, backups, and Multi-AZ replication, reducing operational overhead. Because the application already uses MySQL, migrating to RDS for MySQL requires minimal application changes; often only the connection string needs updating. This aligns with the goal of reducing operational overhead while preserving compatibility and improving scalability.

Application Discovery Service agentless and agent-based collection maps server dependencies automatically, feeding that inventory into Migration Hub. This satisfies the minimise-manual-effort constraint across 200 applications, since Migration Hub can then track each application's migration status without hand-built dependency records.

Amazon RDS Multi-AZ maintains a synchronous standby replica in a second Availability Zone and automatically promotes it during failure, giving the required high availability and automated failover. RDS is fully managed, handling patching, backups and instance replacement.

IAM Identity Center can consume the existing IdP as its identity source through SAML 2.0 federation, so users authenticate against the third-party IdP while Identity Center handles centralised AWS access assignment. This preserves the current SAML 2.0 investment.

Amazon ElastiCache for Redis provides a highly available, in-memory data store that can be used to externalize session state. By storing sessions in ElastiCache, any web server can access the session data, enabling horizontal scaling without losing user sessions. This is a common pattern for modernizing applications to be stateless and scalable.

AWS DMS full load plus ongoing change data capture replicates ongoing transactions continuously, so the Aurora target stays synchronised until cutover. This directly satisfies the minimal-downtime requirement, since the switch happens only after replication lag reaches near zero.

Joining EC2 instances to AWS Managed Microsoft AD lets the .NET application continue using Windows Authentication and Kerberos against a managed domain, so no code changes are needed. This satisfies the minimise-code-changes constraint while retaining Active Directory integration.

From READY_FOR_TEST, MGN has completed initial replication and the staging area holds a bootable snapshot, so the next step is launching a test instance to validate the migrated Windows server before cutover. Testing confirms boot, drivers and applications without affecting the source, satisfying the stem's validation requirement prior to final launch.

Rehosting lifts the Windows Server and SQL Server workload onto Amazon EC2 unchanged, preserving the existing monolith. This requires no code modification or database refactoring, directly satisfying the stated goals of minimal re-architecting effort and fastest migration timeline.

AWS Database Migration Service performs homogeneous MySQL-to-MySQL migrations, automating both schema conversion and ongoing data replication. It satisfies the requirement to automate schema and data movement without manual scripting, using a replication instance that reads from the source and writes to the target while the database stays operational.

Rehosting lifts the application onto AWS infrastructure unchanged, satisfying the no-code-modification constraint. Unlike replatforming, which alters components, or refactoring, which rewrites code, rehosting preserves the monolith as-is. This lets the company migrate quickly, then refactor selected parts later once running in the cloud.

AWS DMS performs the 2 TB full load over the Direct Connect link, then applies change data capture to replicate ongoing changes. Because CDC keeps the target synchronised, the final cutover requires only a brief application outage, minimising downtime.

Refactoring re-architects the monolith into independently deployable microservices, replacing in-process calls with lightweight APIs or asynchronous messaging. This directly resolves the stem's tightly coupled components and high inter-component latency, which lift-and-shift or replatform cannot address since they preserve the existing monolithic structure and coupling.

AWS DMS can perform full load plus ongoing replication (change data capture) from Oracle to Aurora PostgreSQL, minimizing downtime. AWS SCT converts the Oracle schema to PostgreSQL-compatible DDL. This combination allows continuous replication until cutover, meeting the 1-hour window. DMS handles data migration, and SCT handles schema conversion, which is essential for heterogeneous migrations.

AWS Managed Microsoft AD is a managed Active Directory service in AWS. EC2 instances can be domain-joined to this directory, allowing the application to use Windows authentication without code changes. This maintains the same authentication mechanism and minimizes migration effort, as the application continues to use Active Directory.

AWS DMS with ongoing replication performs the initial full load and then continuously applies change data capture from Oracle to Aurora PostgreSQL. Cutover happens once replication lag is negligible, satisfying minimal downtime with minimal manual intervention.

Gateway Load Balancer uses GENEVE encapsulation to transparently redirect traffic to third-party appliances, while Transit Gateway routes inter-subnet and inter-VPC traffic through the inspection VPC. This combination satisfies the requirement to inspect all traffic between subnets without altering routing on each workload.

VMware Cloud on AWS runs the native vSphere stack on dedicated bare-metal hosts, so existing vCenter, vSphere Client, and management workflows continue unchanged. This directly satisfies the stem's constraint of migrating vSphere workloads without retraining staff or re-platforming to native AWS services.

DynamoDB with on-demand capacity stores session state externally, so any EC2 instance in the Auto Scaling group can retrieve it. On-demand mode scales automatically with request volume, removing capacity planning and satisfying the scalable, highly available requirement without sticky sessions.

Amazon RDS for MySQL runs the same MySQL engine, so the application's queries and drivers work unchanged, satisfying the minimal-changes constraint. RDS also removes database patching, backup and server management tasks, directly reducing operational overhead.

Network Load Balancer operates at layer 4, forwarding TCP traffic on port 4444 without interpreting the proprietary binary protocol. This satisfies the requirement to distribute a non-HTTP protocol across multiple EC2 instances, which Application Load Balancer cannot handle.

DMS handles both the initial full load and ongoing replication via change data capture, reading the Oracle redo logs to apply continuous changes to Aurora PostgreSQL. This satisfies the minimal-downtime and ongoing-replication constraints, unlike snapshot-only tools that require an outage window.

AWS Database Migration Service performs heterogeneous Oracle-to-Aurora PostgreSQL conversion and supports ongoing change data capture replication, keeping the source and target synchronised. This satisfies the minimal-downtime constraint, since cutover happens only after replication has caught up.

An Application Load Balancer distributing traffic across an Auto Scaling group spanning multiple Availability Zones delivers both elasticity and fault tolerance. Because the application is stateless, any instance can serve any request, so horizontal scaling and zone redundancy directly satisfy the high availability and scalability goals.

Amazon RDS for SQL Server joined to AWS Managed Microsoft AD supports Windows Authentication, so the legacy application's existing authentication mechanism continues to work without code changes. Replatforming preserves compatibility while removing database administration overhead.

Offline transfer bypasses bandwidth constraints.

AWS AppConfig stores configuration externally and delivers it to ECS tasks at runtime through the AppConfig agent or API, with validation and controlled rollout. This replaces the proprietary configuration management system, satisfying the requirement to store and retrieve configuration dynamically without redeploying the Java containers.

AWS Application Migration Service replicates source servers block-by-block into staging areas and automatically converts them to bootable Amazon EC2 instances, satisfying the automated replication-and-conversion requirement. It supports heterogeneous operating systems and applications across all 50 VMs without manual rebuilds.

Rehosting on EC2 preserves the application with minimal rework, while RDS Custom for SQL Server grants operating system and database-level access needed for compliance. Standard RDS withholds OS access, and replatforming or refactoring would demand significant rework.

Setting up an Oracle read replica and using it as the source for AWS DMS offloads the replication overhead from the primary database, eliminating the CPU bottleneck and allowing the migration to proceed with minimal impact on the production workload.

S3 Event Notifications trigger AWS Lambda directly on each uploaded object, giving the event-driven, serverless processing the workload requires. This removes polling and server management, satisfying the reduced operational overhead constraint, while Lambda scales automatically with the scheduled batch arrivals.

AWS CloudFormation templates codify the full production environment, so during disaster recovery the stack can be provisioned rapidly and repeatably from the pilot light baseline, satisfying the requirement to quickly stand up complete production capacity.

Amazon EFS is a fully managed, elastic NFS file system that can be mounted on EC2 instances across multiple Availability Zones. It provides shared storage with high availability and durability, requiring no application changes. This matches the requirement to replace the shared file system with minimal changes and multi-AZ availability.

Amazon EFS provides a shared, elastic NFS file system that mounts concurrently on EC2 instances in multiple Availability Zones, so containers on different hosts read and write the same data. EBS volumes attach to a single instance and cannot satisfy the shared-storage requirement.

With data split across services, a business operation spanning several of them cannot rely on a single local transaction. Coordinating commits across service boundaries needs compensating actions or saga orchestration, making distributed transaction management a core migration challenge.

With DeleteOnTermination set to false, the EBS root volume survives instance termination, satisfying the requirement that data remains available for a replacement instance. The volume detaches and can be reattached to a new EC2 instance in the same Availability Zone, enabling rapid recovery without restoring from snapshots.