Uploading Files to Amazon S3 in ASP.NET Core with Razor Pages

Alexi Tomala — Tue, 07 Jan 2025 21:12:43 +0000

In this post we are going to explore how to upload file
to our AWS S3 repository from an ASP.NET Core with Razor Pages app.

In this case we make use of Visual studio for the creation and configuration of the solution:
We select and create the Asp.Net project type.

Created the solution we install the package nuget AWSSDK.S3
from the AwsS3 library

For this solution we are going to implement the repository pattern and start creating the interface for the file upload.

namespace WebUploadFileS3.Interfaces
{
    public interface IRepositoryS3
    {
        Task<string> UploadFileAsync(IFormFile file);
    }
}

Now create the class to implement the file upload method

using WebUploadFileS3.Interfaces;
using Amazon.S3;
using Amazon.S3.Model;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Configuration;
using System.Collections.Generic;

namespace WebUploadFileS3.implementation
{
    public class RespositoryS3 : IRepositoryS3
    {
        private readonly IAmazonS3 _s3Client;
        private readonly string _bucketName;

        public RespositoryS3(IConfiguration configuration)
        {
            var accessKey = configuration["AWS:AccessKey"];
            var secretKey = configuration["AWS:SecretKey"];
            var region = configuration["AWS:Region"];
            _bucketName = configuration["AWS:BucketName"];

            _s3Client = new AmazonS3Client(accessKey, secretKey, Amazon.RegionEndpoint.GetBySystemName(region));
        }
        public async Task<string> UploadFileAsync(IFormFile file)
        {
            using var newMemoryStream = new MemoryStream();
            file.CopyTo(newMemoryStream);

            var request = new PutObjectRequest
            {
                BucketName = _bucketName,
                Key = file.FileName,
                InputStream = newMemoryStream,
                ContentType = file.ContentType,
                AutoCloseStream = true
            };
            await _s3Client.PutObjectAsync(request);
            return file.FileName;
        }
    }
}

En el archivo appsettings.json adicionar la credenciales de acceso al servicio AWS S3

"AWS": {
    "AccessKey": "AccessKey",
    "SecretKey": "SecretKey",
    "BucketName": "bucketnet",
    "Region": "Region-1"
  }

Continue adding dependency in Program.cs or Startup file

using Microsoft.AspNetCore.Http.Features;
using WebUploadFileS3.implementation;
using WebUploadFileS3.Interfaces;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddRazorPages();

builder.Services.AddControllersWithViews();
builder.Services.AddScoped<IRepositoryS3, RespositoryS3>();

Finally in the razor page view create file upload form

<div class="text-center">

    @{ ViewData["Title"] = "Upload File"; }
    <h2>Upload File</h2> 
    <form asp-controller="Home" asp-action="Upload" enctype="multipart/form-data" method="post"> 
        <div class="form-group">
            <label for="file">Select to file:</label> 
            <input type="file" name="file" id="file" class="form-control" /> 
        </div>
        <br />
        <button type="submit" class="btn btn-primary">Upload</button>
    </form>
</div>

Check out the source code in: https://github.com/ajtomala/WebUploadFileS3

Please let me know your questions

The Unsung Hero of DevOps AWS X-Ray

Alexi Tomala — Mon, 06 Jan 2025 21:02:02 +0000

AWS X-Ray makes it easy for developers to analyze and debug distributed and production applications, especially those built with a microservices architecture. Find out more at https://aws.amazon.com/xray/

Getting into the nitty-gritty, troubleshooting bugs in a production environment can be a real challenge. Even when end users are not directly affected,
there is often great pressure to identify and fix problems quickly. One of the most effective tools to facilitate this task is AWS X-Ray.
In the devops environment making use of X-Ray is of super benefits since it will allow you to:

Complete Visibility: X-Ray provides a detailed map of your application services, showing how they interact with each other. This is essential for DevOps teams that need to quickly identify latency issues or system failures.
Bottleneck Identification: With X-Ray, you can track application performance and discover where the bottlenecks are. This allows you to optimize the components that really need attention, improving the overall performance of your application.
Continuous Monitoring: AWS X-Ray enables continuous monitoring of your application, which means you can detect problems in real time and take corrective action before they affect end users.

One of the AWS X-Ray Use Cases in DevOps that I'm reviewing is:

Rapid Troubleshooting : Let's imagine your application is experiencing slow response times. With X-Ray, you get to track each request and see where the delays are occurring. This allows you to quickly identify whether the problem is in the code, the database, or an external service.

Application Optimization: The data collected by X-Ray can help you understand how your application resources are being used. You can use this information to optimize the use of CPU, memory and other resources, resulting in better performance and lower operating costs.

Improved User Experience: By identifying and resolving problems before they impact end users, you can improve the user experience. X-Ray helps you maintain high levels of availability and performance, which is critical in today's competitive environment.

Implementing X-Ray in your DevOps environment is easy. Here is a quick guide in .NET:

Installing the SDK: Make sure your application is using the AWS X-Ray SDK. You can easily install it through NuGet for .NET applications.

Install-Package AWSSDK.XRay

Code Instrumentation: Add the necessary calls in your code to send data to X-Ray. This may involve changes to your code to capture request and response data.

using Amazon.XRay.Recorder.Core; 
using Amazon.XRay.Recorder.Handlers.AwsSdk; 
public class Startup
 { 
   public void ConfigureServices(IServiceCollection services) 
   { 
     AWSXRayRecorder.InitializeInstance(); 
    AWSSDKHandler.RegisterXRayForAllServices(); 
   } 
}

Conclusion
AWS X-Ray is an essential tool for DevOps teams looking to keep their distributed applications running optimally. With its ability to provide complete visibility,
identify bottlenecks, and enable continuous monitoring for any DevOps strategy.

DEV Community: Alexi Tomala

Uploading Files to Amazon S3 in ASP.NET Core with Razor Pages

The Unsung Hero of DevOps AWS X-Ray

One of the AWS X-Ray Use Cases in DevOps that I'm reviewing is: