How to Integrate Replit with Backblaze B2

1// Verify all B2 secrets are present at startup
2const required = ['B2_KEY_ID', 'B2_APPLICATION_KEY', 'B2_BUCKET_NAME', 'B2_ENDPOINT', 'B2_REGION'];
3for (const key of required) {
4  if (!process.env[key]) {
5    throw new Error(`Missing required secret: ${key}. Add it in Replit Secrets (lock icon 🔒).`);
6  }
7}
8console.log('B2 secrets verified.');
9console.log('Endpoint:', process.env.B2_ENDPOINT);
10console.log('Bucket:', process.env.B2_BUCKET_NAME);

1// b2.js — Backblaze B2 via S3-compatible API, AWS SDK v3, Node.js on Replit
2const { S3Client, PutObjectCommand, GetObjectCommand, DeleteObjectCommand, ListObjectsV2Command } = require('@aws-sdk/client-s3');
3const { getSignedUrl } = require('@aws-sdk/s3-request-presigner');
4const express = require('express');
5
6// B2 S3-compatible client configuration
7const b2 = new S3Client({
8  endpoint: process.env.B2_ENDPOINT,           // e.g., https://s3.us-west-001.backblazeb2.com
9  region: process.env.B2_REGION,               // e.g., us-west-001
10  credentials: {
11    accessKeyId: process.env.B2_KEY_ID,        // B2 Application Key ID
12    secretAccessKey: process.env.B2_APPLICATION_KEY  // B2 Application Key
13  },
14  forcePathStyle: true                          // REQUIRED for B2 S3-compatible API
15});
16
17const BUCKET = process.env.B2_BUCKET_NAME;
18const app = express();
19app.use(express.json());
20
21// Upload file buffer to B2
22async function uploadToB2(key, buffer, contentType) {
23  await b2.send(new PutObjectCommand({
24    Bucket: BUCKET,
25    Key: key,
26    Body: buffer,
27    ContentType: contentType
28  }));
29  // Return the direct B2 file URL (use CDN URL in production)
30  return `${process.env.B2_ENDPOINT}/${BUCKET}/${key}`;
31}
32
33// Generate a presigned PUT URL for direct browser-to-B2 uploads
34async function getPresignedUploadUrl(key, contentType, expiresIn = 300) {
35  const command = new PutObjectCommand({
36    Bucket: BUCKET,
37    Key: key,
38    ContentType: contentType
39  });
40  return getSignedUrl(b2, command, { expiresIn });
41}
42
43// Generate a presigned GET URL for private file access
44async function getPresignedDownloadUrl(key, expiresIn = 3600) {
45  const command = new GetObjectCommand({ Bucket: BUCKET, Key: key });
46  return getSignedUrl(b2, command, { expiresIn });
47}
48
49// API: request a presigned upload URL
50app.post('/api/upload-url', async (req, res) => {
51  const { filename, contentType } = req.body;
52  const allowed = ['image/jpeg', 'image/png', 'image/gif', 'application/pdf', 'video/mp4'];
53  if (!allowed.includes(contentType)) {
54    return res.status(400).json({ error: 'Content type not allowed' });
55  }
56  const safe = filename.replace(/[^a-zA-Z0-9._-]/g, '_');
57  const key = `uploads/${Date.now()}-${safe}`;
58  try {
59    const uploadUrl = await getPresignedUploadUrl(key, contentType);
60    res.json({ uploadUrl, key });
61  } catch (err) {
62    res.status(500).json({ error: err.message });
63  }
64});
65
66// API: list files in the bucket
67app.get('/api/files', async (req, res) => {
68  try {
69    const result = await b2.send(new ListObjectsV2Command({ Bucket: BUCKET, MaxKeys: 100 }));
70    const files = (result.Contents || []).map(obj => ({ key: obj.Key, size: obj.Size, lastModified: obj.LastModified }));
71    res.json({ files });
72  } catch (err) {
73    res.status(500).json({ error: err.message });
74  }
75});
76
77app.listen(3000, '0.0.0.0', () => console.log('B2 server running on port 3000'));

1# b2_utils.py — Backblaze B2 via S3-compatible API, boto3, Python on Replit
2import boto3
3import os
4from botocore.config import Config
5from flask import Flask, request, jsonify
6
7# Configure boto3 for B2's S3-compatible endpoint
8b2_client = boto3.client(
9    's3',
10    endpoint_url=os.environ['B2_ENDPOINT'],
11    aws_access_key_id=os.environ['B2_KEY_ID'],
12    aws_secret_access_key=os.environ['B2_APPLICATION_KEY'],
13    region_name=os.environ['B2_REGION'],
14    config=Config(signature_version='s3v4')
15)
16
17BUCKET = os.environ['B2_BUCKET_NAME']
18app = Flask(__name__)
19
20def upload_file(key: str, data: bytes, content_type: str) -> str:
21    """Upload bytes to B2 and return file URL."""
22    b2_client.put_object(
23        Bucket=BUCKET,
24        Key=key,
25        Body=data,
26        ContentType=content_type
27    )
28    return f"{os.environ['B2_ENDPOINT']}/{BUCKET}/{key}"
29
30def get_upload_url(key: str, content_type: str, expires: int = 300) -> str:
31    """Generate a presigned PUT URL for direct browser uploads."""
32    return b2_client.generate_presigned_url(
33        'put_object',
34        Params={'Bucket': BUCKET, 'Key': key, 'ContentType': content_type},
35        ExpiresIn=expires
36    )
37
38def get_download_url(key: str, expires: int = 3600) -> str:
39    """Generate a presigned GET URL for private file access."""
40    return b2_client.generate_presigned_url(
41        'get_object',
42        Params={'Bucket': BUCKET, 'Key': key},
43        ExpiresIn=expires
44    )
45
46@app.route('/api/upload-url', methods=['POST'])
47def request_upload_url():
48    data = request.get_json()
49    content_type = data.get('contentType', '')
50    filename = data.get('filename', 'file')
51    allowed = {'image/jpeg', 'image/png', 'image/gif', 'application/pdf', 'video/mp4'}
52    if content_type not in allowed:
53        return jsonify({'error': 'Content type not allowed'}), 400
54    safe = ''.join(c if c.isalnum() or c in '._-' else '_' for c in filename)
55    import time
56    key = f'uploads/{int(time.time())}-{safe}'
57    url = get_upload_url(key, content_type)
58    return jsonify({'uploadUrl': url, 'key': key})
59
60if __name__ == '__main__':
61    app.run(host='0.0.0.0', port=3000)