GoSuda

Redução do tempo de resposta de endpoint em Go - Utilizando Filas de Tarefas

By Yunjin Lee
views ...

Visão Geral

Ao aprender Go pela primeira vez, é comum aprender implementando um servidor de backend. Consideremos um exemplo em que criamos um exemplo que recebe um fluxo de arquivos de uma RestAPI, etc., e o carrega para o servidor. O servidor net/http da linguagem Go lida com múltiplas requisições simultaneamente por padrão, então não há problema com uploads simultâneos em si. No entanto, se todas as operações após o recebimento do fluxo forem processadas de forma síncrona, a resposta do endpoint será atrasada. Vamos explorar uma técnica para evitar tal situação.

Causa

Receber um fluxo geralmente leva muito tempo, e no caso de arquivos grandes, uma única requisição pode ser processada por vários minutos. Nesses casos, é importante processar as operações após o recebimento o mais rápido possível. Este cenário de exemplo é um cenário em que um fluxo é recebido, salvo como um arquivo temporário e, em seguida, enviado para um Container. Neste ponto, se a parte de envio do arquivo temporário para o Container for tratada por um worker pool, o atraso na resposta pode ser reduzido.

 1package file_upload
 2
 3import (
 4	"fmt"
 5	"io"
 6	"log"
 7	"net/http"
 8	"os"
 9	"path/filepath"
10	"time"
11)
12
13const uploadTempDir = "/tmp/incus_uploads" // Diretório temporário do Host
14
15// UploadTask contém dados para envio assíncrono de arquivos.
16type UploadTask struct {
17	HostTempFilePath         string
18	ContainerName            string
19    HostFilename             string
20	ContainerDestinationPath string
21}
22
23// UploadHandler processa uploads de arquivos. Salva em arquivo temporário e, em seguida, enfileira para envio Incus.
24func UploadHandler(wr http.ResponseWriter, req *http.Request) {
25	if req.Method != http.MethodPost {
26		http.Error(wr, "POST method required.", http.StatusMethodNotAllowed)
27		return
28	}
29	originalFilePath := req.Header.Get("X-File-Path")
30    originalFilename := filepath.Base(req.Header.Get("X-Host-Path"))
31	containerName := req.Header.Get("X-Container-Name")
32	if originalFilePath == "" || containerName == "" {
33		http.Error(wr, "Missing X-File-Path or X-Container-Name header.", http.StatusBadRequest)
34		return
35	}
36
37	cleanContainerDestPath := filepath.Clean(originalFilePath)
38	if !filepath.IsAbs(cleanContainerDestPath) {
39		http.Error(wr, "File path must be absolute.", http.StatusBadRequest)
40		return
41	}
42
43	// Cria caminho de arquivo temporário único no Host
44	tempFileName := fmt.Sprintf("%d-%s", time.Now().UnixNano(), filepath.Base(originalFilePath))
45	hostTempFilePath := filepath.Join(uploadTempDir, tempFileName)
46
47	if err := os.MkdirAll(uploadTempDir, 0755); err != nil {
48		log.Printf("ERROR: Failed to create temp upload directory: %v", err)
49		http.Error(wr, "Server error.", http.StatusInternalServerError)
50		return
51	}
52
53	// Cria e copia o corpo da requisição para um arquivo temporário (síncrono)
54	outFile, err := os.Create(hostTempFilePath)
55	if err != nil {
56		log.Printf("ERROR: Failed to create temporary file: %v", err)
57		http.Error(wr, "Server error.", http.StatusInternalServerError)
58		return
59	}
60	defer outFile.Close()
61
62	bytesWritten, err := io.Copy(outFile, req.Body)
63	if err != nil {
64		outFile.Close()
65		os.Remove(hostTempFilePath)
66		log.Printf("ERROR: Failed to copy request body to temp file: %v", err)
67		http.Error(wr, "File transfer failed.", http.StatusInternalServerError)
68		return
69	}
70	log.Printf("Upload Info: Received %d bytes, saved to %s.", bytesWritten, hostTempFilePath)
71
72	// Enfileira a tarefa para envio Incus assíncrono
73	task := UploadTask{
74		HostTempFilePath:         hostTempFilePath,
75		ContainerName:            containerName,
76        HostFilename :            originalFilename,
77		ContainerDestinationPath: cleanContainerDestPath,
78	}
79	EnqueueTask(task) //ESTA PARTE
80	log.Printf("Upload Info: Task enqueued for %s to %s.", originalFilePath, containerName)
81
82	// Envia resposta imediata 202 Accepted
83	wr.WriteHeader(http.StatusAccepted)
84	fmt.Fprintf(wr, "File '%s' queued for processing on container '%s'.\n", originalFilename, containerName)
85}

Neste ponto, você deve ter notado que a parte marcada como THIS PART (ESTA PARTE) indica que a tarefa é inserida em uma fila.

Agora, vamos ver como a fila de tarefas funciona.

 1package file_upload
 2
 3import (
 4	"log"
 5	"sync"
 6)
 7
 8var taskQueue chan UploadTask
 9var once sync.Once
10
11// InitWorkQueue inicializa a fila de tarefas em memória.
12func InitWorkQueue() {
13	once.Do(func() {
14		taskQueue = make(chan UploadTask, 100)
15		log.Println("Upload Info: Work queue initialized.")
16	})
17}
18
19// EnqueueTask adiciona uma UploadTask à fila.
20func EnqueueTask(task UploadTask) {
21	if taskQueue == nil {
22		log.Fatal("ERROR: Task queue not initialized.")
23	}
24	taskQueue <- task
25	log.Printf("Upload Info: Queue: Task enqueued. Size: %d", len(taskQueue))
26}
27
28// DequeueTask recupera uma UploadTask da fila, bloqueando se estiver vazia.
29func DequeueTask() UploadTask {
30	if taskQueue == nil {
31		log.Fatal("ERROR: Task queue not initialized.")
32	}
33	task := <-taskQueue
34	log.Printf("Upload Info: Queue: Task dequeued. Size: %d", len(taskQueue))
35	return task
36}
37
38// GetQueueLength retorna o tamanho atual da fila.
39func GetQueueLength() int {
40	if taskQueue == nil {
41		return 0
42	}
43	return len(taskQueue)
44}

A fila de tarefas fornecida como exemplo é implementada de forma simples. Esta fila de tarefas possui uma estrutura simples que retira as tarefas da fila de um canal.

A seguir, está o método worker para enviar um arquivo para um Container após o upload. O método atual é um loop infinito para boa responsividade e fácil implementação, mas você pode adicionar algoritmos dependendo do seu propósito.

 1func StartFilePushWorker() {
 2	for {
 3		task := DequeueTask()
 4		log.Printf("Upload Info: Worker processing task for %s from %s.", task.ContainerName, task.HostFilename)
 5
 6		// Adia a limpeza do arquivo temporário
 7		defer func(filePath string) {
 8			if err := os.Remove(filePath); err != nil {
 9				log.Printf("ERROR: Worker: Failed to remove temp file '%s': %v", filePath, err)
10			} else {
11				log.Printf("Upload Info: Worker: Cleaned up temp file: %s", filePath)
12			}
13		}(task.HostTempFilePath)
14
15		// Processa a tarefa com novas tentativas para erros Incus transitórios
16		for i := 0; i <= MaxRetries; i++ {
17			err := processUploadTask(task) //tarefa de upload separada
18			if err == nil {
19				log.Printf("SUCCESS: Worker: Task completed for %s.", task.ContainerName)
20				break
21			}
22
23			isTransient := true
24			if err.Error() == "incus: container not found" { // Exemplo de erro permanente
25				isTransient = false
26			}
27
28			if isTransient && i < MaxRetries {
29				log.Printf("WARNING: Worker: Task failed for %s (attempt %d/%d): %v. Retrying.",
30					task.ContainerName, i+1, MaxRetries, err)
31				time.Sleep(RetryDelay)
32			} else {
33				log.Printf("ERROR: Worker: Task permanently failed for %s after %d attempts: %v.",
34					task.ContainerName, i+1, err)
35				break
36			}
37		}
38	}
39}

Primeiramente, esta função tenta continuamente receber tarefas da fila em um loop. Em seguida, ela tenta a etapa de upload de arquivo temporário para Container, em vez de fluxo para arquivo temporário, dentro do escopo de novas tentativas.

Vantagens

A vantagem deste método de processamento é que, se o upload do fluxo for bem-sucedido, ele pode reduzir o atraso nas tarefas subsequentes e prevenir o esgotamento de recursos devido a operações simultâneas do Container. Como pode ser visto no código atual, o número de operações simultâneas do Container é limitado pelo número de canais. Assim, exploramos um exemplo prático de como usar o processamento paralelo em Go. Para mais exemplos, visite os links abaixo.Módulo que inclui exemplos Projeto que usa exemplos O projeto em si tem muitos componentes adicionais, então para aprender sobre o worker em si, você só precisa dar uma olhada breve em como a função de inicialização do worker é chamada em main.go. O módulo também inclui outros tipos de workers, então consulte-o.