File Upload SystemFile Upload System

file tải lên mỗi ngàyuploads a day

300k

file tải lên mỗi ngàyuploads a day

giới hạn ảnh và tài liệulimit for images and documents

25 MB

giới hạn ảnh và tài liệulimit for images and documents

giới hạn video, qua multipartlimit for video, via multipart

5 GB

giới hạn video, qua multipartlimit for video, via multipart

từ lúc tải xong tới khi có thumbnailfrom upload finished to thumbnail ready

< 30s

từ lúc tải xong tới khi có thumbnailfrom upload finished to thumbnail ready

Client xin API một URL đã ký, rồi tải byte thẳng lên S3. S3 phát sự kiện ObjectCreated vào SQS; worker quét virus, tạo thumbnail và cập nhật bảng files. Người xem lấy file qua CloudFront với URL có chữ ký ngắn hạn. Bật “Video 2 GB qua multipart” hoặc “File nhiễm mã độc” để xem hai luồng còn lại.The client asks the API for a signed URL and sends the bytes straight to S3. S3 emits ObjectCreated into SQS; workers scan for malware, build thumbnails and update the files table. Viewers fetch files through CloudFront with a short-lived signed URL. Turn on “2 GB video via multipart” or “Infected file” to see the other two flows.

1. 1

   API thành nút cổ chai khi proxy byteThe API becomes a bottleneck when it proxies bytes

   Đẩy file qua API nghĩa là giữ thread và băng thông của server suốt thời gian tải, 2 GB trên mạng 5 MB/s là gần 7 phút. Presigned URL cho client nói chuyện thẳng với S3; API chỉ ký và ghi trạng thái.Streaming files through the API ties up a server thread and bandwidth for the whole upload; 2 GB over 5 MB/s is close to 7 minutes. A presigned URL lets the client talk to S3 directly while the API only signs and tracks status.

   FacadeProxy
2. 2

   Client gửi file to hơn hoặc khác loại đã khaiClient sends a bigger file or a different type than declared

   Kiểm tra ở API là chưa đủ vì byte không đi qua API. Presigned POST đặt điều kiện content-length-range và Content-Type trong policy; presigned PUT đưa Content-Length và Content-Type vào chữ ký. Sau đó HEAD object khi confirm và kiểm tra magic bytes khi quét, vì Content-Type do client tự khai.Checking at the API is not enough because the bytes skip it. A presigned POST puts content-length-range and Content-Type conditions in its policy; a presigned PUT signs Content-Length and Content-Type. Then HEAD the object on confirm and check magic bytes during the scan, because the client chooses Content-Type.

   Facade
3. 3

   File lớn hỏng giữa chừngLarge uploads fail half way

   Multipart chia file thành part 5 MB tới 5 GB (tối đa 10.000 part). Mỗi part có URL ký riêng và thử lại độc lập; ListParts cho biết part nào đã có để tải tiếp sau khi mất mạng.Multipart splits the file into parts of 5 MB to 5 GB (up to 10,000 parts). Each part has its own signed URL and retries independently; ListParts shows which parts exist so the upload resumes after a disconnect.

   CommandRetry with Exponential Backoff
4. 4

   Quét và xử lý chạy trong requestScanning and processing inside the request

   S3 phát sự kiện ObjectCreated vào SQS; scan worker rồi processing worker xử lý theo từng bước. Message lỗi quá 5 lần vào DLQ. Worker phải idempotent vì SQS giao ít nhất một lần.S3 emits ObjectCreated into SQS; the scan worker and then the processing worker handle it stage by stage. A message that fails 5 times goes to the DLQ. Workers must be idempotent because SQS delivers at least once.

   PipelineProducer-ConsumerWorker Pool
5. 5

   Upload bỏ dở tốn tiền âm thầmAbandoned uploads quietly cost money

   Part của multipart chưa complete không hiện trong danh sách object nhưng vẫn bị tính phí. Lifecycle rule AbortIncompleteMultipartUpload sau 1 ngày, rule xoá prefix tmp/, và job dọn dòng files UPLOADING quá 24 giờ.Parts of an unfinished multipart upload do not show up as objects but are still billed. Add a lifecycle rule AbortIncompleteMultipartUpload after 1 day, an expiry rule on tmp/, and a job that clears files rows stuck in UPLOADING for over 24 hours.

   Command
6. 6

   Lộ file qua URL công khaiFiles exposed through public URLs

   Bucket private, chỉ CloudFront đọc qua Origin Access Control. API ký URL CDN 5 phút sau khi kiểm tra quyền và status=READY. Adapter bọc S3, MinIO hoặc GCS sau cùng một interface lưu trữ.Keep the bucket private and let only CloudFront read it through Origin Access Control. The API signs a 5-minute CDN URL after checking access and status=READY. An adapter hides S3, MinIO or GCS behind one storage interface.

   AdapterProxy

Hai việc của Upload API: kiểm tra giới hạn rồi ký URL, và xác nhận upload bằng HEAD object. Không có byte nào đi qua đây.The Upload API does two things: check limits and sign a URL, then confirm the upload with a HEAD on the object. No bytes pass through it.

@Service
@RequiredArgsConstructor
public class UploadService {
    private static final long MAX_BYTES = 25L * 1024 * 1024;
    private static final Set<String> ALLOWED = Set.of("image/jpeg", "image/png", "application/pdf");
    private final S3Presigner presigner;
    private final S3Client s3;
    private final FileRepository files;

    @Transactional
    public PresignResponse presign(UUID ownerId, PresignRequest req) {
        if (req.size() > MAX_BYTES || !ALLOWED.contains(req.contentType()))1
            throw new InvalidUploadException("size or type not allowed");
        FileRecord f = files.save(FileRecord.uploading(ownerId, req));
        PutObjectRequest put = PutObjectRequest.builder()
            .bucket("uploads").key(f.objectKey())
            .contentType(req.contentType())
            .contentLength(req.size())2
            .build();
        PresignedPutObjectRequest url = presigner.presignPutObject(b -> b
            .signatureDuration(Duration.ofMinutes(10))
            .putObjectRequest(put));
        return new PresignResponse(f.id(), url.url(), url.signedHeaders());
    }

    @Transactional
    public void confirm(UUID ownerId, UUID fileId) {
        FileRecord f = files.lockOwned(fileId, ownerId);   // SELECT … FOR UPDATE3
        if (f.status() != FileStatus.UPLOADING) return;     // second confirm: no-op
        HeadObjectResponse head = s3.headObject(b -> b.bucket("uploads").key(f.objectKey()));
        if (head.contentLength() != f.declaredSize()) {4
            f.reject("size mismatch");
            return;
        }
        f.markScanning(head.eTag());                        // workers set READY
    }
}

type UploadService struct {
	presign *s3.PresignClient
	s3      *s3.Client
	files   FileStore
}

const maxBytes = 25 << 20

var allowed = map[string]bool{"image/jpeg": true, "image/png": true, "application/pdf": true}

func (s *UploadService) Presign(ctx context.Context, owner uuid.UUID, req PresignRequest) (*PresignResponse, error) {
	if req.Size > maxBytes || !allowed[req.ContentType] {
		return nil, ErrInvalidUpload
	}
	f, err := s.files.CreateUploading(ctx, owner, req)
	if err != nil {
		return nil, err
	}
	post, err := s.presign.PresignPostObject(ctx, &s3.PutObjectInput{1
		Bucket: aws.String("uploads"), Key: aws.String(f.ObjectKey),
	}, func(o *s3.PresignPostOptions) {
		o.Expires = 10 * time.Minute
		o.Conditions = []interface{}{
			[]interface{}{"content-length-range", 1, maxBytes},2
			[]interface{}{"eq", "$Content-Type", req.ContentType},
		}
	})
	if err != nil {
		return nil, err
	}
	return &PresignResponse{FileID: f.ID, URL: post.URL, Fields: post.Values}, nil
}

func (s *UploadService) Confirm(ctx context.Context, owner, id uuid.UUID) error {
	return s.files.WithLock(ctx, id, owner, func(f *File) error {
		if f.Status != StatusUploading {
			return nil // already confirmed3
		}
		head, err := s.s3.HeadObject(ctx, &s3.HeadObjectInput{
			Bucket: aws.String("uploads"), Key: aws.String(f.ObjectKey),
		})
		if err != nil {
			return err // object not in S3 yet
		}
		if aws.ToInt64(head.ContentLength) != f.DeclaredSize {
			return f.Reject("size mismatch")
		}
		return f.MarkScanning(aws.ToString(head.ETag))4
	})
}

Mỗi pattern mở bài học tương ứng trong menu Pattern.Each one opens its lesson in the Patterns menu.