Como Fazer Upload e Download de Arquivos no Azure Blob Storage, AWS S3 e YouTube Usando Node.js

No cenário atual de desenvolvimento, muitas aplicações web e móveis precisam de funcionalidades para o upload e download de arquivos, seja para armazenar documentos, fotos ou até vídeos. Entre os serviços de nuvem mais populares, temos o AWS S3, Azure Blob Storage e o YouTube (para upload de vídeos). Este artigo vai te guiar pela implementação de uma solução em Node.js que permite realizar o upload e download de arquivos nesses serviços, com a escolha do serviço sendo um parâmetro da requisição.

Pré-requisitos

Antes de começarmos, certifique-se de ter o seguinte:

• Conta na AWS com acesso ao S3.
• Conta na Azure com o serviço de Blob Storage configurado.
• Conta no Google Developer Console com as credenciais da API do YouTube configuradas.

O que Vamos Usar

Para realizar o upload e download de arquivos, utilizaremos as bibliotecas oficiais dos respectivos serviços:

• AWS S3: Utilizaremos o SDK da AWS (aws-sdk).
• Azure Blob Storage: Utilizaremos o pacote @azure/storage-blob.
• YouTube API: Usaremos a biblioteca googleapis para upload de vídeos no YouTube.
• Multer: Um middleware para lidar com uploads de arquivos no Node.js.

Passo 1: Instalação das Dependências

Vamos começar instalando as bibliotecas que serão utilizadas no projeto:

npm install @azure/storage-blob aws-sdk googleapis multer

Essas bibliotecas permitirão que a aplicação interaja com os serviços de nuvem e gerencie o upload de arquivos de maneira eficiente.

Passo 2: Configurando o Código Node.js

Aqui está o código que faz o upload e download dos arquivos para os três serviços, com a escolha sendo feita com base no parâmetro enviado na requisição.

const express = require('express');
const multer = require('multer');
const { BlobServiceClient } = require('@azure/storage-blob');
const AWS = require('aws-sdk');
const { google } = require('googleapis');
const fs = require('fs');
const path = require('path');

// Configurações do AWS S3

const s3 = new AWS.S3({
    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
    region: process.env.AWS_REGION
});

// Configurações do Azure Blob Storage

const azureBlobServiceClient = BlobServiceClient.fromConnectionString(process.env.AZURE_STORAGE_CONNECTION_STRING);
const containerName = process.env.AZURE_CONTAINER_NAME;

// Configurações da API do YouTube

const oauth2Client = new google.auth.OAuth2(
    process.env.YOUTUBE_CLIENT_ID,
    process.env.YOUTUBE_CLIENT_SECRET,
    'https://developers.google.com/oauthplayground' // Redirect URL
);

oauth2Client.setCredentials({
    access_token: process.env.YOUTUBE_ACCESS_TOKEN,
    refresh_token: process.env.YOUTUBE_REFRESH_TOKEN,
});

// Middleware Multer para upload de arquivos
const upload = multer({ dest: 'uploads/' });
const app = express();

// Rota de upload de arquivos
app.post('/upload', upload.single('file'), async (req, res) => {
    const { service } = req.body;  // Parâmetro para escolher o serviço: 'azure', 's3', ou 'youtube'
    const file = req.file;
    try {
        if (service === 'azure') {
            // Upload no Azure Blob Storage
            const blobClient = azureBlobServiceClient.getContainerClient(containerName).getBlockBlobClient(file.originalname);
            await blobClient.uploadFile(file.path);
            res.json({ message: 'Arquivo enviado para o Azure Blob Storage!' });
        } else if (service === 's3') {
            // Upload no AWS S3
            const fileContent = fs.readFileSync(file.path);
            const params = {
                Bucket: process.env.AWS_S3_BUCKET,
                Key: file.originalname,
                Body: fileContent
            };
            await s3.upload(params).promise();
            res.json({ message: 'Arquivo enviado para o AWS S3!' });
        } else if (service === 'youtube') {
            // Upload de vídeo no YouTube
            const youtube = google.youtube({ version: 'v3', auth: oauth2Client });
            const videoFilePath = path.join(__dirname, file.path);
            const videoStream = fs.createReadStream(videoFilePath);
            const response = await youtube.videos.insert({
                part: 'snippet,status',
                requestBody: {
                    snippet: {
                        title: file.originalname,
                        description: 'Upload via Node.js',
                        tags: ['nodejs', 'upload']
                    },
                    status: {
                        privacyStatus: 'private'
                    }
                },
                media: {
                    body: videoStream
                }
            });
            res.json({ message: 'Vídeo enviado para o YouTube!', videoId: response.data.id });
        } else {
            res.status(400).json({ error: 'Serviço inválido' });
        }
    } catch (err) {
        console.error('Erro ao fazer upload:', err);
        res.status(500).json({ error: 'Erro ao fazer upload' });
    } finally {
        // Remove o arquivo local temporário
        fs.unlinkSync(file.path);
    }
});

// Rota de download de arquivos (apenas para Azure e S3)
app.get('/download/:service/:filename', async (req, res) => {
    const { service, filename } = req.params;
    try {
        if (service === 'azure') {
            const blobClient = azureBlobServiceClient.getContainerClient(containerName).getBlockBlobClient(filename);
            const downloadBlockBlobResponse = await blobClient.download(0);
            downloadBlockBlobResponse.readableStreamBody.pipe(res);
        } else if (service === 's3') {
            const params = {
                Bucket: process.env.AWS_S3_BUCKET,
                Key: filename
            };
            const s3Stream = s3.getObject(params).createReadStream();
            s3Stream.pipe(res);
        } else {
            res.status(400).json({ error: 'Download disponível apenas para Azure e S3' });
        }
    } catch (err) {
        console.error('Erro ao baixar arquivo:', err);
        res.status(500).json({ error: 'Erro ao baixar arquivo' });
    }
});

app.listen(3000, () => {
    console.log('Servidor rodando na porta 3000');
});

Passo 3: Configurando Variáveis de Ambiente

Para que o código funcione corretamente, você precisará configurar algumas variáveis de ambiente. Crie um arquivo .env ou defina-as diretamente no seu ambiente de execução com os seguintes valores:

# Credenciais AWS S3
AWS_ACCESS_KEY_ID=seu_access_key_id
AWS_SECRET_ACCESS_KEY=seu_secret_access_key
AWS_REGION=sua_regiao_aws
AWS_S3_BUCKET=nome_do_bucket
# Credenciais Azure Blob Storage
AZURE_STORAGE_CONNECTION_STRING=sua_connection_string_azure
AZURE_CONTAINER_NAME=nome_do_container_azure
# Credenciais YouTube API
YOUTUBE_CLIENT_ID=seu_client_id_youtube
YOUTUBE_CLIENT_SECRET=seu_client_secret_youtube
YOUTUBE_ACCESS_TOKEN=seu_access_token_youtube
YOUTUBE_REFRESH_TOKEN=seu_refresh_token_youtube

Como Funciona

1. Upload de Arquivos: A rota /upload permite fazer upload de um arquivo, escolhendo o serviço de destino através de um parâmetro enviado junto na requisição (azure, s3, ou youtube). Dependendo do valor, o arquivo é enviado para o respectivo serviço.
2. Download de Arquivos: A rota /download/:service/:filename permite baixar arquivos armazenados no Azure Blob Storage ou no AWS S3.

Conclusão

Com esse exemplo, agora você tem uma aplicação Node.js que consegue interagir com três dos serviços de armazenamento mais usados: AWS S3, Azure Blob Storage, e YouTube para vídeos. Isso oferece uma grande flexibilidade para gerenciar arquivos em diferentes plataformas, seja para upload ou download.

Se você gostou desse artigo, fique à vontade para deixar seus comentários ou dúvidas!