How to send large file from controller endpoint in ASP.NET Core

I'm trying to send a quite large .zip archive from my asp.net api controller.
My setup is something like this:
I have an Angular frontend that makes a GET request for an archive file.

public getArchive(archiveName: string): Observable<any> {
    return this.http.get(
        `${this.runtimeConfig.backendApiPath}api/tenants/${this.auth.profile.tid}/objects/archives/${archiveName}`,
        {
            headers: new HttpHeaders({ Authorization: `Bearer ${this.auth.accessToken}` }),
        });
}

Then this request is handled in a Backend For Frontend (BFF) api:

[HttpGet("archives/{archiveName}")]
public async Task<IActionResult> GetArchive(
    [FromRoute] string archiveName)
{
    try
    {
        var result = await this._objectsServiceClient.GetArchive(archiveName);

        return Ok(result);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, $"Error while retrieving archive.");
        return BadRequest(ex.Message);
    }
}

the service returns a byte[] that is coming from a GET request from the backend Api:

public Task<byte[]> GetArchive(string archiveName)
{
    var url = $@"{this.options.BackendUrl}"
                .AppendPathSegments("api", "tenants", $"{this.tenantInfo.TenantId}", "objects", "archives", archiveName)
                .SetQueryParam("api-version", "1.0")
                .ToString();

    var res = this.Get<byte[]>(url);

    return res;
}

and the this.Get<byte[]> method I have:

protected async Task<T> Get<T>(string url)
{
    var response = await _httpClient.GetAsync(new Uri(url));
    await response.EnsureSuccessStatusCodeExtendedAsync();

    var retVal = await response.Content.ReadAsAsync<T>();
    return retVal;
}

The backend controller's endpoint has the following code:

[HttpGet("objects/archives/{archiveName}")]
public async Task<IActionResult> GetArchive(Guid tenantId, [FromRoute] string archiveName)
{
    using (Infrastructure.Extensions.LoggerExtensions.BeginScope(
               this.logger,
               LoggingScopeField.TenantId(tenantId)))
    {
        try
        {
            var path = new BlobStorageRepoPathBuilder()
                .WithId(tenantId)
                .WithPath("archives")
                .WithId(this.userInfo.UserId)
                .WithPath($"{archiveName}.zip")
                .Build();

            var blob = await this.repo.DownloadAsync(path);

            using (MemoryStream ms = new MemoryStream())
            {
                await blob.Stream.CopyToAsync(ms);
                ms.Position = 0;

                return Ok(ms.ToArray());
            }
        }
        catch (Exception ex)
        {
            this.logger.LogError(ex, "Error occurred during report generation.");
            return this.BadRequest("Error occurred during report generation. Please check the logs.");
        }
    }
}

Basically I download the file from a file storage, load it in a MemoryStream and send it as a byte[].This works fine with small files (I know that using MemoryStream is not the best decision, that's why I want to change that), but when a large file comes (like more than 2GB) I got an OutOfMemory exceptions. I found out an article that describes how to receive a large file, not to send one as a response.

So my question is, how can I handle large (>2GB) files, and remove the MemoryStream from the equation

Thanks in advance!

I'm not 100% sure how the internals of this.repo.DownloadAsync work since it's not included in your question, but it appears that it just provides the direct IO response stream from the file source (which looks like Azure Blob Storage). If that's the case, why not just stream the file to the client?:

var blob = await this.repo.DownloadAsync(path);
return File(blob.Stream, "application/zip", fileDownloadName: $"{archiveName}.zip");

From your comment on this answer, it seems like this.repo.DownloadAsync is using HttpClient based on your comment. To directly get the stream from HttpClient you can use the following code:

HttpClient client; // your HttpClient instance that you're already using
var stream = await client.GetStreamAsync(theUrl);

The stream will be returned to you after the HTTP response readers have been received, and then you can return this to your controller method, and then to the client using return File to directly stream the result through your server without first downloading it.