Armazenamento de objetos

import { GetObjectCommand, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
import { getSignedUrl } from "@aws-sdk/s3-request-presigner";

// Na AWS, endpoint e forcePathStyle saem; o SDK lê as credenciais do ambiente
const s3 = new S3Client({
  endpoint: process.env.S3_ENDPOINT,
  forcePathStyle: true,
  region: "us-east-1",
  // Sem isto, o SDK põe na URL o checksum de um corpo vazio, e todo envio com conteúdo falha
  requestChecksumCalculation: "WHEN_REQUIRED",
});
const BUCKET = "arquivos";

// O navegador envia direto para o armazenamento, sem passar pela aplicação.
// O tipo entra na assinatura: um envio com outro tipo é recusado.
export const urlDeEnvio = (chave: string, tipo: string, segundos = 300) =>
  getSignedUrl(s3, new PutObjectCommand({ Bucket: BUCKET, Key: chave, ContentType: tipo }), {
    expiresIn: segundos,
    signableHeaders: new Set(["content-type"]), // sem isto, o tipo não entra na assinatura
  });

// O download sai como anexo: o navegador não abre o arquivo como página do seu domínio
export const urlDeDownload = (chave: string, segundos = 300) =>
  getSignedUrl(s3, new GetObjectCommand({
    Bucket: BUCKET, Key: chave,
    ResponseContentDisposition: "attachment",
    ResponseContentType: "application/octet-stream",
  }), { expiresIn: segundos });

console.log(await urlDeEnvio("fotos/ts.png", "image/png"));
console.log(await urlDeDownload("fotos/ts.png"));

import os

import boto3
from botocore.config import Config

# Na AWS, endpoint_url e o estilo de endereço saem; o SDK lê as credenciais do ambiente
s3 = boto3.client(
    "s3",
    endpoint_url=os.environ.get("S3_ENDPOINT"),
    region_name="us-east-1",
    config=Config(signature_version="s3v4", s3={"addressing_style": "path"}),
)
BUCKET = "arquivos"


def url_de_envio(chave: str, tipo: str, segundos: int = 300) -> str:
    """O navegador envia direto para o armazenamento. O tipo entra na assinatura."""
    return s3.generate_presigned_url(
        "put_object",
        Params={"Bucket": BUCKET, "Key": chave, "ContentType": tipo},
        ExpiresIn=segundos,
    )


def url_de_download(chave: str, segundos: int = 300) -> str:
    """O download sai como anexo, e não como página do seu domínio."""
    return s3.generate_presigned_url(
        "get_object",
        Params={
            "Bucket": BUCKET,
            "Key": chave,
            "ResponseContentDisposition": "attachment",
            "ResponseContentType": "application/octet-stream",
        },
        ExpiresIn=segundos,
    )


print(url_de_envio("fotos/py.png", "image/png"))
print(url_de_download("fotos/py.png"))

package main

import (
	"context"
	"fmt"
	"os"
	"time"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/service/s3"
)

const bucket = "arquivos"

// urlDeEnvio: o navegador envia direto para o armazenamento; o tipo entra na assinatura
func urlDeEnvio(
	ctx context.Context, p *s3.PresignClient, chave, tipo string, validade time.Duration,
) (string, error) {
	r, err := p.PresignPutObject(ctx, &s3.PutObjectInput{
		Bucket: aws.String(bucket), Key: aws.String(chave), ContentType: aws.String(tipo),
	}, s3.WithPresignExpires(validade))
	if err != nil {
		return "", err
	}
	return r.URL, nil
}

// urlDeDownload: o download sai como anexo, e não como página do seu domínio
func urlDeDownload(
	ctx context.Context, p *s3.PresignClient, chave string, validade time.Duration,
) (string, error) {
	r, err := p.PresignGetObject(ctx, &s3.GetObjectInput{
		Bucket: aws.String(bucket), Key: aws.String(chave),
		ResponseContentDisposition: aws.String("attachment"),
		ResponseContentType:        aws.String("application/octet-stream"),
	}, s3.WithPresignExpires(validade))
	if err != nil {
		return "", err
	}
	return r.URL, nil
}

func main() {
	ctx := context.Background()
	cfg, err := config.LoadDefaultConfig(ctx, config.WithRegion("us-east-1"))
	if err != nil {
		panic(err)
	}
	// Na AWS, BaseEndpoint e UsePathStyle saem
	cliente := s3.NewFromConfig(cfg, func(o *s3.Options) {
		o.BaseEndpoint = aws.String(os.Getenv("S3_ENDPOINT"))
		o.UsePathStyle = true
	})
	p := s3.NewPresignClient(cliente)
	envio, _ := urlDeEnvio(ctx, p, "fotos/go.png", "image/png", 5*time.Minute)
	download, _ := urlDeDownload(ctx, p, "fotos/go.png", 5*time.Minute)
	fmt.Println(envio)
	fmt.Println(download)
}

import java.net.URI;
import java.time.Duration;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Configuration;
import software.amazon.awssdk.services.s3.model.GetObjectRequest;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;
import software.amazon.awssdk.services.s3.presigner.S3Presigner;
import software.amazon.awssdk.services.s3.presigner.model.GetObjectPresignRequest;
import software.amazon.awssdk.services.s3.presigner.model.PutObjectPresignRequest;

public class Urls {
    static final String BUCKET = "arquivos";

    // Na AWS, endpointOverride e pathStyleAccess saem; o SDK lê as credenciais do ambiente
    static final S3Presigner PRESIGNER = S3Presigner.builder()
        .region(Region.US_EAST_1)
        .endpointOverride(URI.create(System.getenv("S3_ENDPOINT")))
        .serviceConfiguration(S3Configuration.builder().pathStyleAccessEnabled(true).build())
        .build();

    // O navegador envia direto para o armazenamento; o tipo entra na assinatura
    static String urlDeEnvio(String chave, String tipo, Duration validade) {
        var pedido = PutObjectRequest.builder().bucket(BUCKET).key(chave).contentType(tipo).build();
        return PRESIGNER.presignPutObject(PutObjectPresignRequest.builder()
            .signatureDuration(validade).putObjectRequest(pedido).build()).url().toString();
    }

    // O download sai como anexo, e não como página do seu domínio
    static String urlDeDownload(String chave, Duration validade) {
        var pedido = GetObjectRequest.builder().bucket(BUCKET).key(chave)
            .responseContentDisposition("attachment")
            .responseContentType("application/octet-stream").build();
        return PRESIGNER.presignGetObject(GetObjectPresignRequest.builder()
            .signatureDuration(validade).getObjectRequest(pedido).build()).url().toString();
    }

    public static void main(String[] args) {
        System.out.println(urlDeEnvio("fotos/java.png", "image/png", Duration.ofMinutes(5)));
        System.out.println(urlDeDownload("fotos/java.png", Duration.ofMinutes(5)));
    }
}

using Amazon.S3;
using Amazon.S3.Model;

// Na AWS, ServiceURL e ForcePathStyle saem; o SDK lê as credenciais do ambiente
var s3 = new AmazonS3Client(new AmazonS3Config
{
    ServiceURL = Environment.GetEnvironmentVariable("S3_ENDPOINT"),
    ForcePathStyle = true,
    AuthenticationRegion = "us-east-1",
});
const string Bucket = "arquivos";

// O navegador envia direto para o armazenamento; o tipo entra na assinatura
Task<string> UrlDeEnvio(string chave, string tipo, TimeSpan validade) =>
    s3.GetPreSignedURLAsync(new GetPreSignedUrlRequest
    {
        BucketName = Bucket, Key = chave, Verb = HttpVerb.PUT, ContentType = tipo,
        Expires = DateTime.UtcNow.Add(validade),
        Protocol = Protocol.HTTP, // só no teste, com o servidor local sem HTTPS
    });

// O download sai como anexo, e não como página do seu domínio
Task<string> UrlDeDownload(string chave, TimeSpan validade)
{
    var pedido = new GetPreSignedUrlRequest
    {
        BucketName = Bucket, Key = chave, Verb = HttpVerb.GET,
        Expires = DateTime.UtcNow.Add(validade),
        Protocol = Protocol.HTTP,
    };
    pedido.ResponseHeaderOverrides.ContentDisposition = "attachment";
    pedido.ResponseHeaderOverrides.ContentType = "application/octet-stream";
    return s3.GetPreSignedURLAsync(pedido);
}

Console.WriteLine(await UrlDeEnvio("fotos/cs.png", "image/png", TimeSpan.FromMinutes(5)));
Console.WriteLine(await UrlDeDownload("fotos/cs.png", TimeSpan.FromMinutes(5)));