Mount remote storage

import { Sha256 } from '@aws-crypto/sha256-js';
import { SignatureV4 } from '@smithy/signature-v4';
import { awsCredentialsProvider } from '@vercel/oidc-aws-credentials-provider';
import { defineSandboxProxy } from '@vercel/sandbox/proxy';
 
const signer = new SignatureV4({
  service: 's3',
  region: process.env.AWS_REGION!,
  credentials: awsCredentialsProvider({
    roleArn: process.env.AWS_ROLE_ARN!,
    // The role's trust policy must allow this audience.
    // See /docs/oidc/aws#custom-audience.
    audience: 'sts.amazonaws.com',
  }),
  sha256: Sha256,
  // Unlike other AWS services, S3 paths must not be escaped again
  // when signing.
  uriEscapePath: false,
});
 
const handler = defineSandboxProxy(async (request, meta) => {
  // The request is already re-targeted at the original S3 URL.
  const url = new URL(request.url);
 
  // Authorize before signing. With path-style requests the path is
  // /<bucket>/<key>, so you can restrict each sandbox to its own key
  // prefix, for example one derived from meta.sandboxId.
 
  // Sign only headers that carry client intent. Forwarding the whole
  // incoming header set breaks SigV4 validation, because infrastructure
  // adds headers along the way that are not part of the signature.
  const SIGNED_PASSTHROUGH = [
    'content-type',
    'content-md5',
    'range',
    'if-match',
    'if-none-match',
    'if-modified-since',
    'if-unmodified-since',
  ];
  const headers: Record<string, string> = {
    host: url.host,
    'x-amz-content-sha256': 'UNSIGNED-PAYLOAD',
  };
  for (const [key, value] of request.headers) {
    if (key.startsWith('x-amz-') || SIGNED_PASSTHROUGH.includes(key)) {
      headers[key] = value;
    }
  }
 
  const body =
    request.method === 'GET' || request.method === 'HEAD'
      ? undefined
      : new Uint8Array(await request.arrayBuffer());
 
  const signed = await signer.sign({
    method: request.method,
    protocol: url.protocol,
    hostname: url.hostname,
    path: url.pathname,
    query: Object.fromEntries(url.searchParams),
    headers,
  });
 
  return fetch(url, {
    method: request.method,
    headers: signed.headers,
    body,
  });
});
 
// mount-s3 reads objects with GET and HEAD and writes them with PUT,
// POST, and DELETE, so expose the handler under all of them.
export {
  handler as GET,
  handler as HEAD,
  handler as PUT,
  handler as POST,
  handler as DELETE,
};

import { Sandbox } from '@vercel/sandbox';
 
const sandbox = await Sandbox.create();
 
try {
  // Refresh the package index. The sandbox starts without one.
  await sandbox.runCommand({
    sudo: true,
    cmd: 'apt-get',
    args: ['update'],
  });
 
  // apt-get cannot install from a URL, so download the package first.
  await sandbox.runCommand({
    cmd: 'curl',
    args: [
      '-sL',
      '-o',
      '/tmp/mount-s3.deb',
      'https://s3.amazonaws.com/mountpoint-s3-release/latest/x86_64/mount-s3.deb',
    ],
  });
 
  // Install Mountpoint for Amazon S3. It pulls in its own FUSE dependency.
  await sandbox.runCommand({
    sudo: true,
    cmd: 'apt-get',
    args: ['install', '-y', '/tmp/mount-s3.deb'],
  });
 
  const MOUNT_DIR = '/mnt/s3';
 
  await sandbox.runCommand({
    sudo: true,
    cmd: 'mkdir',
    args: ['-p', MOUNT_DIR],
  });
 
  // Route all S3 traffic through the signing proxy. No other egress is
  // allowed. Add "*": [] to keep general Internet access for other domains.
  await sandbox.update({
    networkPolicy: {
      allow: {
        's3.amazonaws.com': [
          { forwardURL: 'https://my-project.vercel.app/api/s3-proxy' },
        ],
      },
    },
  });
 
  // Mount without credentials. --no-sign-request skips signing in the
  // sandbox, and --force-path-style keeps the request host on
  // s3.amazonaws.com so it matches the domain rule above.
  await sandbox.runCommand({
    sudo: true,
    cmd: 'mount-s3',
    args: [
      process.env.S3_BUCKET_NAME,
      MOUNT_DIR,
      '--allow-other',
      '--no-sign-request',
      '--force-path-style',
      '--endpoint-url',
      'https://s3.amazonaws.com',
    ],
  });
 
  // List the files in your bucket to confirm the mount.
  await sandbox.runCommand({
    cmd: 'ls',
    args: ['-la', MOUNT_DIR],
    stdout: process.stdout,
  });
} finally {
  await sandbox.stop();
}