CCNA Accelerate Workload Migration and Modernization Questions

The progress update stream is named DMS, and Migration Hub attributes each task to the service that reported it. The failed task was therefore submitted by AWS Database Migration Service, making DMS the service responsible for the failure.

Fargate removes the need to provision or patch EC2 instances, since ECS schedules the PHP container tasks onto AWS-managed compute. This directly satisfies the minimal operational overhead constraint while delivering the containerisation-based scalability and faster deployments the LAMP migration requires.

Amazon EFS is a fully managed, scalable, and highly available NFS file system that can be mounted on multiple EC2 instances across Availability Zones. It supports POSIX permissions and can be used without application changes. This makes it ideal for a shared file system for configuration files and user uploads, meeting the requirements for high availability and scalability.

AWS Managed Microsoft AD supplies the managed domain for Windows authentication, FSx for Windows File Server provides the shared SMB file system, and Elastic Beanstalk removes patching and scaling overhead, satisfying the minimise-operational-overhead and managed-services constraints.

COM+ relies on Windows-specific component services unavailable on Linux, so recompilation is impossible. Rehosting to Windows Server EC2 preserves the proprietary binary unchanged, satisfying the constraint that the component cannot be recompiled while still moving to AWS.

Amazon RDS supports several commercial engines on specific instance classes, and it provides automated backups, patching, and Multi-AZ failover without schema changes. Because the engine stays the same, the application's SQL and drivers remain compatible, satisfying the minimal-change requirement. This reduces operational overhead compared with self-managed EC2 while honoring vendor licensing constraints.

Managed relational with up to 15 read replicas.

AWS DMS with change data capture performs a full load then continuously replicates ongoing changes from the source database to Amazon RDS, keeping the target synchronised until cutover. This minimises downtime because the application stays live on the source during migration, with only a brief final switchover.

Amazon EC2 Dedicated Hosts give the instance exclusive use of a physical server, so no other tenants share the host and CPU stealing cannot occur. This satisfies the requirement for consistent performance and low latency.

Amazon Aurora is a fully managed relational engine, so it satisfies the requirement to minimise operational overhead: AWS handles provisioning, patching, backups and replication. Unlike self-managed engines on Amazon EC2, Aurora removes database administration, and its MySQL and PostgreSQL compatibility suits a legacy relational workload being migrated.

MGN replicates the legacy server to Amazon EC2 with minimal application change, while AWS DMS migrates the SQL Server database to Amazon RDS for SQL Server, a managed service that reduces operational overhead and preserves engine compatibility.

AWS Schema Conversion Tool is designed to convert database schemas and code objects from one database engine to another, such as from Oracle to PostgreSQL. It automatically converts stored procedures, triggers, and views, and provides an assessment report highlighting items that require manual intervention. This directly reduces manual effort and accelerates the migration to Aurora PostgreSQL.

AWS DMS full load copies the existing 5 TB dataset, then ongoing replication applies change data capture from the source transaction logs, continuously propagating writes to Aurora PostgreSQL. This keeps the target current until cutover, achieving the minimal downtime the migration demands.

AWS Batch manages the compute environment, queueing and scheduling, removing the cron and EC2 instance maintenance. It satisfies the reduced-operational-overhead constraint while handling the two-hour S3-sourced job, since Batch supports long-running jobs that AWS Lambda's fifteen-minute limit would preclude.

Rehosting on Amazon EC2 preserves the application's existing code, satisfying the minimal-change constraint, while Amazon RDS supplies managed Multi-AZ high availability and read-replica scalability for the legacy database. Because the monolith cannot be refactored, lift-and-shift onto EC2 with a managed database engine avoids code rewrites yet still delivers the required resilience.

Replacing the self-signed certificate with one issued by a trusted Certificate Authority satisfies the Migration Hub validation requirement, because the agent's TLS handshake to the service endpoint is rejected when the chain cannot be verified. A publicly trusted CA resolves that trust failure without altering network paths or agent configuration.

ElastiCache for Redis externalises session state into a shared, low-latency store, so any Auto Scaling web instance can read the same session regardless of which server handled the prior request. It satisfies the stem's constraint that locally stored sessions break horizontal scaling behind a load balancer.

Amazon EFS provides a fully managed, scalable, and durable NFS file system that can be mounted on multiple EC2 instances across AZs. It requires no application code changes and supports high availability. The lifecycle policy optimizes cost by moving less frequently accessed files to EFS IA storage class.

Amazon WorkSpaces delivers persistent virtual desktops, so the existing thick client runs unmodified on managed cloud-hosted Windows instances. This satisfies the reduced desktop administration and remote access constraints without refactoring the client-server application, unlike application-streaming or SaaS alternatives that would require code changes.

Rehosting on Amazon EC2 with AWS Application Migration Service lifts and shifts the SOAP application unchanged, satisfying the minimal-changes constraint. MGN replicates the existing server to AWS without refactoring, and EC2 keeps operational overhead lower than replatforming or rebuilding the legacy SOAP stack.

AWS MGN requires the migrated instance to use DHCP; a static IP carried over from the source VM prevents the EC2 instance from obtaining its network configuration, failing the post-cutover health check. Changing the source VM to DHCP before cutover satisfies this constraint.

An Auto Scaling group spanning two AZs behind an Application Load Balancer removes single points of failure for the stateless tiers, while Multi-AZ Amazon RDS handles database failover automatically. This delivers the highest availability with the least administrative effort, as failover is managed by AWS.

Amazon EFS provides a shared, POSIX-compliant NFS file system that multiple EC2 instances across Availability Zones can mount concurrently, meeting the shared-uploads-and-logs requirement. Its regional, replicated design delivers the durability and high availability demanded, while general-purpose performance mode keeps latency low for file operations.

Moving session state into ElastiCache or DynamoDB externalises it from the instance, so any instance in the Auto Scaling group can serve any request. The ALB distributes traffic, delivering the required high availability and horizontal scalability.

Amazon EFS provides a shared, elastic NFS file system that multiple containers across an ECS cluster can mount concurrently, satisfying the persistent shared-storage requirement. It scales automatically and supports both EC2 and Fargate launch types.

App2Container analyses running .NET Framework applications, containerises them and generates ECS or EKS deployment artefacts with minimal code changes. This directly satisfies the containerised AWS requirement while avoiding the re-architecture that replatforming tools or manual containerisation would demand.

A full transaction log halts SQL Server's ability to record further changes, so DMS change data capture cannot read new log records and the replication task fails. The stem's ongoing replication failure, following a successful full load, points to log growth from unbacked-up or untruncated logs rather than connectivity or permissions.

EC2 Windows instances preserve Windows authentication (Kerberos/NTLM) unchanged, while Amazon FSx for Windows File Server provides SMB shares with NTFS ACLs, replacing the local file system dependency. Together they satisfy the minimal-code-change constraint because the .NET application sees the same authentication and file path semantics.

The ALB target group lacks stickiness, so the load balancer distributes each request independently across web instances. Without session affinity, users hit different instances and lose session state, matching the reported logouts and the stem's sticky-session requirement.

AWS Direct Connect provisions a dedicated private network link from on-premises equipment to an AWS location, bypassing the public internet. This delivers consistent low latency and predictable bandwidth, satisfying the hybrid migration requirement for a dedicated connection, unlike VPN tunnels that traverse shared internet paths.

Amazon EFS provides a POSIX-compliant NFSv4 file system that mounts natively on Linux, so the legacy application's existing file paths and locking semantics remain unchanged. Its managed, multi-AZ design delivers the scalable, highly available shared storage the stem requires, minimising migration effort compared with re-architecting onto object or block storage.

Amazon RDS for Oracle runs the Oracle engine natively, so the existing schema, PL/SQL and drivers migrate unchanged. Multi-AZ deployments provide synchronous standby across Availability Zones, and read replicas can be added, minimising migration effort.

Correct. Using EMR with r5.8xlarge instances closely matches the on-premises resources (64 vCPUs, 256 GB RAM per node) and using S3 with EMRFS eliminates HDFS overhead, reducing costs and management effort while maintaining performance via Direct Connect.

Reduces requests to the origin servers.

FSx for Windows File Server provides SMB shares with native NTFS permissions and Active Directory integration, so the legacy .NET application keeps Windows authentication and a shared file system without code changes. It satisfies the shared-storage constraint that Linux-based Amazon EFS cannot meet for this workload.

AWS DataSync performs incremental, scheduled or one-off copies over the network with integrity verification, moving the local EC2 data onto EFS during the maintenance window. This satisfies the constraint of preserving existing stateful data while the application becomes stateless.

Amazon S3 provides durable, scalable object storage for static assets, and Amazon CloudFront is a global content delivery network that caches content at edge locations, reducing latency for users worldwide. This combination decouples storage from compute, enables high availability across multiple Availability Zones, and supports global low-latency access. It aligns with modernizing the application to be scalable and highly available.

Dedicated Hosts give you a physical server with visibility and control over socket and core allocation, which satisfies bring-your-own-licence requirements tied to physical cores or sockets. Other purchasing options, such as Savings Plans or Reserved Instances, do not provide that host-level licensing visibility.

Amazon SQS provides asynchronous, queue-based decoupling so microservices scale independently without blocking callers, satisfying the decoupling and scalability requirements. Aurora MySQL is wire-compatible with MySQL, so the existing database engine and queries migrate without rewriting, meeting the stem's MySQL constraint.

An Application Load Balancer routes HTTP and HTTPS requests to microservice targets, supporting path- and host-based rules for synchronous REST traffic. It satisfies the REST API communication requirement at layer 7, unlike Network Load Balancer, which balances TCP without HTTP awareness.

The Strangler Fig pattern routes reads and writes incrementally to DynamoDB while the MySQL database remains authoritative, allowing dual-write or change-data-capture synchronisation. This satisfies the refactor-to-DynamoDB goal without a risky big-bang cutover, since each migrated capability can be validated before decommissioning legacy tables.

RDS MySQL read replicas use asynchronous replication to serve read-only queries from separate instances, offloading the primary and reducing read latency. This directly satisfies the heavy read-traffic requirement by horizontally scaling read capacity without changing application write logic.

AWS Application Migration Service replicates the on-premises server block-level and launches it on Amazon EC2, so the Java application runs without modification. This lifts operational overhead to AWS and enables multi-AZ resilience while minimising code changes.

AWS Application Migration Service replicates live source servers continuously at block level, launching them on AWS as EC2 instances. This satisfies the stem's automation and minimal-downtime constraints: agents install automatically, and cutover occurs in minutes, unlike snapshot-based tools requiring manual orchestration or extended outages.

Replatforming swaps the licensed commercial engine for Amazon RDS PostgreSQL, eliminating per-core licence fees while retaining managed backups, patching and Multi-AZ. This satisfies the cost-reduction goal without the re-architecting effort of refactoring the application's data layer.

Amazon SQS decouples the tiers by letting the frontend enqueue order messages while backend workers poll and process them asynchronously. This buffers traffic spikes, allows independent scaling of each tier, and prevents frontend requests from blocking on backend processing, satisfying the asynchronous order requirement.

AWS Migration Hub provides a centralised view of application discovery and migration status across multiple tools, satisfying the need to assess the environment and track migration progress. It aggregates data from AWS Application Discovery Service and Migration Evaluator, letting the company plan migrations from one dashboard rather than per-service consoles.

Porting to .NET Core enables the application to run on Linux, satisfying the platform constraint, while CoreWCF provides WCF service compatibility with minimal code changes. Amazon ECS with Linux containers then hosts the modernised workload, meeting both the "minimise code changes" and "run on Linux" requirements in the stem.

AWS Application Discovery Service uses agentless or agent-based collection to map server dependencies, network connections and process data across both Windows and Linux hosts. This directly satisfies the stem's requirement to automate discovery of application dependencies before migration, feeding that inventory into Migration Hub for progress tracking.

The strangler fig pattern incrementally routes functionality and its data to new microservices while the monolith keeps serving, avoiding a big-bang cutover. This gradual, reversible migration is what achieves zero downtime with a shared PostgreSQL database.

The strangler fig pattern routes traffic incrementally to new microservices while the monolith keeps running, so the team can adopt unfamiliar NoSQL stores one bounded, non-critical function at a time and roll back easily, directly minimising migration risk.

AWS DMS with ongoing replication allows continuous data replication from the on-premises SQL Server to Amazon RDS for SQL Server, minimizing downtime during cutover. After the initial full load, change data capture keeps the target in sync until the application is ready to switch. This approach ensures data consistency and supports modernization by moving to a managed database service.

Wave-based migration groups applications by dependency and business function, so each wave can be migrated, tested and rolled back independently. This directly limits blast radius across hundreds of applications, satisfying the stem's requirement to reduce migration risk rather than attempting a single cutover.

AWS Lambda runs Java code without provisioning or managing servers, satisfying the minimise-operational-overhead constraint. It integrates natively with S3 event notifications, so uploaded files trigger processing automatically. For batch workloads with intermittent file arrivals, this event-driven model removes idle capacity and patching duties entirely, unlike EC2 or ECS, which require ongoing cluster management.

VMware Cloud on AWS runs the native vSphere stack on dedicated AWS hardware, so existing VMware management tools such as vCenter and vSphere Client keep working unchanged. That directly satisfies the requirement to maintain the same management tooling and operational consistency during migration.

Rehosting lifts the application onto Amazon EC2 unchanged, while Amazon RDS runs MySQL with the same engine, so connection strings and SQL remain compatible. This minimises application code changes, which is the explicit constraint the company specified for migration.

Joining EC2 instances to AWS Managed Microsoft AD preserves Windows Authentication (Kerberos) without rewriting the identity layer, and the managed domain removes self-managed domain controller overhead. This meets both constraints: minimal code change and use of an AWS managed service.

Amazon RDS Multi-AZ maintains a synchronous standby in a second Availability Zone with automatic failover, satisfying the availability requirement. RDS also removes database patching, backups and replication administration, directly addressing the reduced administrative overhead constraint.

EMRFS lets EMR read and write HDFS-compatible data directly in Amazon S3, so the cluster's storage layer persists independently of transient EC2 nodes. This decouples compute from storage, allowing clusters to be terminated between jobs and cutting the cost of maintaining replicated HDFS volumes.

AWS CloudFormation defines infrastructure declaratively through JSON or YAML templates, letting the company version, review and provision the multi-tier stack repeatably. It satisfies the IaC requirement by managing resource creation and dependencies as code rather than manual console actions.

Limited LOB mode truncates or rejects LOBs exceeding the specified MaxLobSize, causing the full-load errors on LOB tables. Switching to Full LOB mode migrates complete LOB values regardless of size, satisfying the requirement for accurate replication of the Oracle data.

AWS SCT converts the Oracle schema and code to Aurora PostgreSQL-compatible objects, and AWS DMS with CDC performs an initial full load followed by continuous replication of ongoing changes. This allows the target to stay synchronized with the source while the application is still writing to Oracle, enabling a cutover with minimal downtime and no data loss. This is the standard approach for heterogeneous database migrations to Aurora.

Amazon S3 is a highly durable, scalable object storage service that decouples storage from compute. By storing documents in S3, the application can be stateless, enabling independent scaling of microservices. S3 also provides features like versioning, lifecycle policies, and event notifications that can trigger downstream processing, making it ideal for modernized applications.

Flyway runs versioned SQL migrations against each service's RDS for PostgreSQL instance, tracking applied changes in its own schema history table. Embedded as a CodeBuild build step, it applies pending migrations before deployment, satisfying the requirement to automate schema changes per microservice within the existing CI/CD pipeline.

Amazon Redshift is a fully managed, petabyte-scale data warehouse service designed for complex analytical queries. It uses columnar storage and massively parallel processing to deliver high performance. It is the ideal choice for migrating an on-premises data warehouse to AWS.

AWS DMS supports continuous replication from an on-premises PostgreSQL database to Amazon RDS for PostgreSQL, keeping the target in sync until cutover. AWS MGN replicates the application server block-level, enabling a staged cutover. This combination minimizes downtime and maintains synchronization, aligning with the requirement for a brief read-only period.

AWS DMS performs the initial full load and ongoing change data capture replication, keeping the source Oracle database available while data transfers over the existing Direct Connect link. This satisfies the requirement to minimise downtime, unlike offline export or backup-based approaches.

An Auto Scaling group with a simple scaling policy triggered by a CloudWatch CPU utilisation alarm adjusts desired capacity automatically, satisfying the CPU-based scaling requirement. The Application Load Balancer distributes traffic across the scaled instances, keeping the architecture responsive under varying load.

Snowball Edge bypasses the 100 Mbps link, which would take over 46 days for 50 TB, meeting the one-week deadline. DataSync then preserves NTFS discretionary access control lists and the folder hierarchy when copying into Amazon FSx for Windows File Server, satisfying the permission-retention requirement.

Rehosting on Amazon EMR preserves the existing MapReduce and Spark APIs, so job code and operational tooling transfer with minimal modification. This directly satisfies the stem's constraint of minimising code and process changes, unlike replatforming to serverless or rewriting jobs for a different engine.

DMS performs continuous change data capture from the source Oracle database, replicating ongoing transactions to Aurora PostgreSQL until cutover. This satisfies the minimal-downtime and data-integrity constraints, unlike a one-off snapshot export, because replication keeps the target synchronised right up to the switch.

Amazon SNS provides pub/sub messaging, letting microservices publish events to topics and fan out to multiple subscribers without direct coupling. This satisfies the stem's requirement for event-driven communication between microservices, decoupling producers from consumers. It complements database decoupling by removing synchronous point-to-point calls, enabling asynchronous, scalable event distribution across services.

Amazon SQS decouples components by providing a durable, fully managed message queue that buffers asynchronous communication, so producers and consumers no longer call each other directly. This directly satisfies the stem's requirement to break the monolithic application's direct component-to-component calls, absorbing traffic spikes and tolerating consumer failures without losing messages.