Génération de PDF LaTeX serverless sur Lambda

import json
import os
import urllib.request
import boto3


def lambda_handler(event, context):
    """Compile LaTeX to PDF via FormaTeX API and store the result in S3."""
    source = event.get("source", "")
    engine = event.get("engine", "pdflatex")

    if not source:
        return {
            "statusCode": 400,
            "body": json.dumps({"error": "source is required"}),
        }

    # API key stored as a Lambda environment variable (or fetched from
    # Secrets Manager at cold-start — see the IAM section below).
    api_key = os.environ["FORMATEX_API_KEY"]

    payload = json.dumps({"latex": source, "engine": engine}).encode()
    req = urllib.request.Request(
        "https://api.formatex.io/api/v1/compile",
        data=payload,
        headers={
            "X-API-Key": api_key,
            "Content-Type": "application/json",
        },
        method="POST",
    )

    with urllib.request.urlopen(req, timeout=25) as resp:
        pdf_bytes = resp.read()

    s3 = boto3.client("s3")
    bucket = os.environ["OUTPUT_BUCKET"]
    key = f"pdfs/{context.aws_request_id}.pdf"
    s3.put_object(Bucket=bucket, Key=key, Body=pdf_bytes, ContentType="application/pdf")

    return {
        "statusCode": 200,
        "body": json.dumps({"bucket": bucket, "key": key}),
    }

import https from "node:https"
import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3"

const s3 = new S3Client({})

// Cache the API key across warm invocations
let cachedApiKey: string | undefined

export const handler = async (event: {
  source: string
  engine?: string
  requestId?: string
}) => {
  const { source, engine = "pdflatex" } = event

  if (!source) {
    return { statusCode: 400, body: JSON.stringify({ error: "source is required" }) }
  }

  if (!cachedApiKey) {
    cachedApiKey = process.env.FORMATEX_API_KEY
  }
  if (!cachedApiKey) throw new Error("FORMATEX_API_KEY is not set")

  const pdfBuffer = await compilePdf(cachedApiKey, source, engine)

  const bucket = process.env.OUTPUT_BUCKET!
  const key = `pdfs/${event.requestId ?? Date.now()}.pdf`

  await s3.send(
    new PutObjectCommand({
      Bucket: bucket,
      Key: key,
      Body: pdfBuffer,
      ContentType: "application/pdf",
    }),
  )

  return { statusCode: 200, body: JSON.stringify({ bucket, key }) }
}

function compilePdf(apiKey: string, source: string, engine: string): Promise<Buffer> {
  return new Promise((resolve, reject) => {
    const body = JSON.stringify({ latex: source, engine })
    const options = {
      hostname: "api.formatex.io",
      path: "/api/v1/compile",
      method: "POST",
      headers: {
        "X-API-Key": apiKey,
        "Content-Type": "application/json",
        "Content-Length": Buffer.byteLength(body),
      },
    }
    const req = https.request(options, (res) => {
      const chunks: Buffer[] = []
      res.on("data", (c: Buffer) => chunks.push(c))
      res.on("end", () => {
        if (res.statusCode !== 200) {
          reject(new Error(`FormaTeX error: HTTP ${res.statusCode}`))
        } else {
          resolve(Buffer.concat(chunks))
        }
      })
    })
    req.on("error", reject)
    req.write(body)
    req.end()
  })
}

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "ReadFormaTeXApiKey",
      "Effect": "Allow",
      "Action": "secretsmanager:GetSecretValue",
      "Resource": "arn:aws:secretsmanager:us-east-1:123456789012:secret:formatex/api-key-*"
    },
    {
      "Sid": "WriteOutputBucket",
      "Effect": "Allow",
      "Action": ["s3:PutObject"],
      "Resource": "arn:aws:s3:::your-output-bucket/pdfs/*"
    }
  ]
}

# Store the secret in Secrets Manager (one-time setup):
aws secretsmanager create-secret \
  --name formatex/api-key \
  --secret-string '{"FORMATEX_API_KEY":"your-key-here"}'

# Then fetch it at cold-start in Python:
# import boto3, json
# secret = boto3.client("secretsmanager").get_secret_value(SecretId="formatex/api-key")
# api_key = json.loads(secret["SecretString"])["FORMATEX_API_KEY"]