feat: add support for Web App ARM deployments on ECS Fargate

.autover/changes/3bbbb972-6181-431c-8313-097ce38a2463.json

@@ -0,0 +1,11 @@
+{
+  "Projects": [
+    {
+      "Name": "AWS.Deploy.CLI",
+      "Type": "Minor",
+      "ChangelogMessages": [
+        "Add support for deploying ARM web apps to ECS Fargate"
+      ]
+    }
+  ]
+}

src/AWS.Deploy.Orchestration/CdkAppSettingsSerializer.cs

@@ -53,7 +53,8 @@ public string Build(CloudApplication cloudApplication, Recommendation recommenda
                 ECRRepositoryName = recommendation.DeploymentBundle.ECRRepositoryName ?? "",
                 ECRImageTag = recommendation.DeploymentBundle.ECRImageTag ?? "",
                 DotnetPublishZipPath = recommendation.DeploymentBundle.DotnetPublishZipPath ?? "",
-                DotnetPublishOutputDirectory = recommendation.DeploymentBundle.DotnetPublishOutputDirectory ?? ""
+                DotnetPublishOutputDirectory = recommendation.DeploymentBundle.DotnetPublishOutputDirectory ?? "",
+                EnvironmentArchitecture = recommendation.DeploymentBundle.EnvironmentArchitecture.ToString()
             };
 
             // Persist deployment bundle settings

src/AWS.Deploy.Orchestration/DeploymentBundleHandler.cs

@@ -74,9 +74,11 @@ public async Task BuildDockerImage(CloudApplication cloudApplication, Recommenda
             DockerUtilities.TryGetAbsoluteDockerfile(recommendation, _fileManager, _directoryManager, out var dockerFile);
 
             var dockerBuildCommand = $"docker build -t {imageTag} -f \"{dockerFile}\"{buildArgs} .";
-            if (RuntimeInformation.OSArchitecture != Architecture.X64)
+            var currentArchitecture = RuntimeInformation.OSArchitecture == Architecture.Arm64 ? SupportedArchitecture.Arm64 : SupportedArchitecture.X86_64;
+            var dockerPlatform = recommendation.DeploymentBundle.EnvironmentArchitecture == SupportedArchitecture.Arm64 ? "linux/arm64" : "linux/amd64";
+            if (currentArchitecture != recommendation.DeploymentBundle.EnvironmentArchitecture)
             {
-                dockerBuildCommand = $"docker buildx build --platform linux/amd64 -t {imageTag} -f \"{dockerFile}\"{buildArgs} .";
+                dockerBuildCommand = $"docker buildx build --platform {dockerPlatform} -t {imageTag} -f \"{dockerFile}\"{buildArgs} .";
             }
 
             _interactiveService.LogInfoMessage($"Docker Execution Directory: {Path.GetFullPath(dockerExecutionDirectory)}");

src/AWS.Deploy.Recipes.CDK.Common/RecipeProps.cs

@@ -41,6 +41,11 @@ public interface IRecipeProps<T>
         /// </summary>
         string? DotnetPublishOutputDirectory { get; set; }
 
+        /// <summary>
+        /// The CPU architecture of the environment to create.
+        /// </summary>
+        string? EnvironmentArchitecture { get; set; }
+
         /// <summary>
         /// The ID of the recipe being used to deploy the application.
         /// </summary>
@@ -62,7 +67,7 @@ public interface IRecipeProps<T>
         string? DeploymentBundleSettings { get; set; }
 
         /// <summary>
-        /// The Region used during deployment. 
+        /// The Region used during deployment.
         /// </summary>
         string? AWSRegion { get; set; }
 
@@ -108,6 +113,11 @@ public class RecipeProps<T> : IRecipeProps<T>
         /// </summary>
         public string? DotnetPublishOutputDirectory { get; set; }
 
+        /// <summary>
+        /// The CPU architecture of the environment to create.
+        /// </summary>
+        public string? EnvironmentArchitecture { get; set; }
+
         /// <summary>
         /// The ID of the recipe being used to deploy the application.
         /// </summary>
@@ -129,7 +139,7 @@ public class RecipeProps<T> : IRecipeProps<T>
         public string? DeploymentBundleSettings { get; set; }
 
         /// <summary>
-        /// The Region used during deployment. 
+        /// The Region used during deployment.
         /// </summary>
         public string? AWSRegion { get; set; }
 

src/AWS.Deploy.Recipes/CdkTemplates/AspNetAppEcsFargate/Generated/Recipe.cs

@@ -135,7 +135,11 @@ private void ConfigureECSClusterAndService(IRecipeProps<Configuration> recipeCon
             {
                 TaskRole = AppIAMTaskRole,
                 Cpu = settings.TaskCpu,
-                MemoryLimitMiB = settings.TaskMemory
+                MemoryLimitMiB = settings.TaskMemory,
+                RuntimePlatform = new RuntimePlatform
+                {
+                    CpuArchitecture = CpuArchitecture.Of(recipeConfiguration.EnvironmentArchitecture ?? string.Empty)
+                }
             }));
 
             AppLogging = new AwsLogDriver(InvokeCustomizeCDKPropsEvent(nameof(AppLogging), this, new AwsLogDriverProps

src/AWS.Deploy.Recipes/RecipeDefinitions/ASP.NETAppECSFargate.recipe

@@ -1,7 +1,7 @@
 {
     "$schema": "./aws-deploy-recipe-schema.json",
     "Id": "AspNetAppEcsFargate",
-    "Version": "1.1.2",
+    "Version": "1.2.0",
     "Name": "ASP.NET Core App to Amazon ECS using AWS Fargate",
     "DeploymentType": "CdkProject",
     "DeploymentBundle": "Container",
@@ -11,7 +11,7 @@
     "Description": "This ASP.NET Core application will be deployed to Amazon Elastic Container Service (Amazon ECS) with compute power managed by AWS Fargate compute engine. If your project does not contain a Dockerfile, it will be automatically generated, otherwise an existing Dockerfile will be used. Recommended if you want to deploy your application as a container image on Linux.",
     "TargetService": "Amazon Elastic Container Service",
     "TargetPlatform": "Linux",
-    "SupportedArchitectures": [ "x86_64" ],
+    "SupportedArchitectures": [ "x86_64", "arm64" ],
 
     "DisplayedResources": [
         {

test/AWS.Deploy.CLI.IntegrationTests/WebAppWithDockerFileTests.cs

@@ -253,6 +253,55 @@ public async Task AppRunnerDeployment()
             Assert.True(await _cloudFormationHelper.IsStackDeleted(_stackName));
         }
 
+        [Fact]
+        public async Task FargateArmDeployment()
+        {
+            _stackName = $"FargateArmDeployment{Guid.NewGuid().ToString().Split('-').Last()}";
+
+            // Arrange input for deploy
+            await _interactiveService.StdInWriter.WriteAsync(Environment.NewLine); // Select default recommendation
+            await _interactiveService.StdInWriter.WriteLineAsync("8"); // Select "Environment Architecture"
+            await _interactiveService.StdInWriter.WriteLineAsync("2"); // Select "Arm64"
+            await _interactiveService.StdInWriter.WriteAsync(Environment.NewLine); // Confirm selection and deploy
+            await _interactiveService.StdInWriter.FlushAsync();
+
+            // Deploy
+            var projectPath = _testAppManager.GetProjectPath(Path.Combine("testapps", "WebAppWithDockerFile", "WebAppWithDockerFile.csproj"));
+            var deployArgs = new[] { "deploy", "--project-path", projectPath, "--application-name", _stackName, "--diagnostics" };
+            Assert.Equal(CommandReturnCodes.SUCCESS, await _app.Run(deployArgs));
+
+            // Verify application is deployed and running
+            Assert.Equal(StackStatus.CREATE_COMPLETE, await _cloudFormationHelper.GetStackStatus(_stackName));
+
+            var deployStdOut = _interactiveService.StdOutReader.ReadAllLines();
+
+            var applicationUrl = deployStdOut.First(line => line.Trim().StartsWith("Endpoint:"))
+                .Split(" ")[1]
+                .Trim();
+
+            // URL could take few more minutes to come live, therefore, we want to wait and keep trying for a specified timeout
+            await _httpHelper.WaitUntilSuccessStatusCode(applicationUrl, TimeSpan.FromSeconds(5), TimeSpan.FromMinutes(5));
+
+            // list
+            var listArgs = new[] { "list-deployments", "--diagnostics" };
+            Assert.Equal(CommandReturnCodes.SUCCESS, await _app.Run(listArgs));;
+
+            // Verify stack exists in list of deployments
+            var listDeployStdOut = _interactiveService.StdOutReader.ReadAllLines().Select(x => x.Split()[0]).ToList();
+            Assert.Contains(listDeployStdOut, (deployment) => _stackName.Equals(deployment));
+
+            // Arrange input for delete
+            await _interactiveService.StdInWriter.WriteAsync("y"); // Confirm delete
+            await _interactiveService.StdInWriter.FlushAsync();
+            var deleteArgs = new[] { "delete-deployment", _stackName, "--diagnostics" };
+
+            // Delete
+            Assert.Equal(CommandReturnCodes.SUCCESS, await _app.Run(deleteArgs));;
+
+            // Verify application is deleted
+            Assert.True(await _cloudFormationHelper.IsStackDeleted(_stackName));
+        }
+
         public void Dispose()
         {
             Dispose(true);

test/AWS.Deploy.CLI.UnitTests/DeploymentBundleHandlerTests.cs

@@ -73,6 +73,64 @@ public DeploymentBundleHandlerTests()
                 It.IsAny<string>()).Object;
         }
 
+        [Fact]
+        public async Task BuildDockerImage_EnvironmentArchitectureNotSet()
+        {
+            var projectPath = SystemIOUtilities.ResolvePath("WebAppWithDockerFile");
+            var project = await _projectDefinitionParser.Parse(projectPath);
+            var recommendation = new Recommendation(_recipeDefinition, project, 100, new Dictionary<string, object>());
+
+            var cloudApplication = new CloudApplication("WebAppWithDockerFile", string.Empty, CloudApplicationResourceType.CloudFormationStack, recommendation.Recipe.Id);
+            var imageTag = "imageTag";
+            var dockerFilePath = Path.GetFullPath(Path.Combine(".", "Dockerfile"), recommendation.GetProjectDirectory());
+
+            await _deploymentBundleHandler.BuildDockerImage(cloudApplication, recommendation, imageTag);
+
+            // Explicitly checking for X64 because the default value for EnvironmentArchitecture is X86_64
+            // This test will help catch a change in the default value
+            if (RuntimeInformation.OSArchitecture.Equals(Architecture.X64))
+            {
+                Assert.Equal($"docker build -t {imageTag} -f \"{dockerFilePath}\" .",
+                    _commandLineWrapper.CommandsToExecute.First().Command);
+            }
+            else
+            {
+                Assert.Equal($"docker buildx build --platform linux/amd64 -t {imageTag} -f \"{dockerFilePath}\" .",
+                    _commandLineWrapper.CommandsToExecute.First().Command);
+            }
+        }
+
+        [Theory]
+        [InlineData(SupportedArchitecture.X86_64)]
+        [InlineData(SupportedArchitecture.Arm64)]
+        public async Task BuildDockerImage_EnvironmentArchitectureIsSet(SupportedArchitecture environmentArchitecture)
+        {
+            var projectPath = SystemIOUtilities.ResolvePath("WebAppWithDockerFile");
+            var project = await _projectDefinitionParser.Parse(projectPath);
+            var recommendation = new Recommendation(_recipeDefinition, project, 100, new Dictionary<string, object>());
+
+            var cloudApplication = new CloudApplication("WebAppWithDockerFile", string.Empty, CloudApplicationResourceType.CloudFormationStack, recommendation.Recipe.Id);
+            var imageTag = "imageTag";
+            var dockerFilePath = Path.GetFullPath(Path.Combine(".", "Dockerfile"), recommendation.GetProjectDirectory());
+
+            recommendation.DeploymentBundle.EnvironmentArchitecture = environmentArchitecture;
+
+            await _deploymentBundleHandler.BuildDockerImage(cloudApplication, recommendation, imageTag);
+
+            var currentArchitecture = RuntimeInformation.OSArchitecture == Architecture.Arm64 ? SupportedArchitecture.Arm64 : SupportedArchitecture.X86_64;
+            if (currentArchitecture.Equals(environmentArchitecture))
+            {
+                Assert.Equal($"docker build -t {imageTag} -f \"{dockerFilePath}\" .",
+                    _commandLineWrapper.CommandsToExecute.First().Command);
+            }
+            else
+            {
+                var dockerPlatform = recommendation.DeploymentBundle.EnvironmentArchitecture == SupportedArchitecture.Arm64 ? "linux/arm64" : "linux/amd64";
+                Assert.Equal($"docker buildx build --platform {dockerPlatform} -t {imageTag} -f \"{dockerFilePath}\" .",
+                    _commandLineWrapper.CommandsToExecute.First().Command);
+            }
+        }
+
         [Fact]
         public async Task BuildDockerImage_DockerExecutionDirectoryNotSet()
         {
@@ -198,15 +256,15 @@ public async Task InspectDockerImage_ExecutedCommandCheck()
 
             await _deploymentBundleHandler.InspectDockerImageEnvironmentVariables(recommendation, "imageTag");
 
-            if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
-                Assert.Equal("docker inspect --format '{{ index (index .Config.Env) }}' imageTag",
-                _commandLineWrapper.CommandsToExecute.First().Command);
+                Assert.Equal("docker inspect --format \"{{ index (index .Config.Env) }}\" imageTag",
+                    _commandLineWrapper.CommandsToExecute.First().Command);
             }
             else
             {
-                Assert.Equal("docker inspect --format \"{{ index (index .Config.Env) }}\" imageTag",
-                _commandLineWrapper.CommandsToExecute.First().Command);
+                Assert.Equal("docker inspect --format '{{ index (index .Config.Env) }}' imageTag",
+                    _commandLineWrapper.CommandsToExecute.First().Command);
             }
         }