Como Subir e Gerenciar Arquivos no Amazon S3 Usando PHP e Por Que Configurar uma Distribuição do CloudFront

Com a crescente necessidade de armazenar arquivos na nuvem, o Amazon S3 (Simple Storage Service) se destaca como uma solução robusta e escalável. Neste post, vamos te guiar na criação de um sistema PHP para gerenciar arquivos no S3, utilizando boas práticas de desenvolvimento e segurança. Além disso, vamos explorar como a configuração de uma distribuição do Amazon CloudFront pode otimizar o acesso aos seus arquivos, reduzindo custos e melhorando a performance.

Visão Geral

O Amazon S3 é amplamente utilizado para armazenamento de arquivos, enquanto o Amazon CloudFront pode ser empregado para entrega de conteúdo de forma rápida e segura. Aqui, vamos configurar um projeto PHP para realizar uploads no S3, obter URLs através do CloudFront, e discutir as vantagens de usar o CloudFront para acessar seus arquivos.

Estrutura do Projeto

Seu projeto será estruturado da seguinte forma:

project/
├── src/
│   ├── S3Manager.php
│   └── example.php
├── .env
├── composer.json
└── README.md

Dependências Necessárias

Antes de começar, certifique-se de ter o Composer instalado, pois ele gerenciará as dependências do seu projeto PHP. No arquivo composer.json, adicione as seguintes dependências:

{
    "require": {
        "aws/aws-sdk-php": "^3.0",
        "vlucas/phpdotenv": "^5.4"
    }
}

Em seguida, instale as dependências:

composer install

Configurando Variáveis de Ambiente

Utilize um arquivo .env para gerenciar configurações sensíveis, como chaves de acesso AWS. O conteúdo do seu arquivo .env deve ser algo como:

AWS_ACCESS_KEY_ID=your_access_key_id
AWS_SECRET_ACCESS_KEY=your_secret_access_key
AWS_REGION=your_aws_region
S3_BUCKET_NAME=your_s3_bucket_name
CLOUDFRONT_URL=https://your_cloudfront_distribution_url/

Criando a Classe de Gerenciamento de Arquivos no S3

Crie a classe S3Manager.php para gerenciar uploads e recuperação de URLs:

<?php

namespace App;

use Aws\S3\S3Client;
use Dotenv\Dotenv;

class S3Manager
{
    private $s3;
    private $bucket;
    private $cloudfrontUrl;

    public function __construct()
    {
        $dotenv = Dotenv::createImmutable(__DIR__ . '/../');
        $dotenv->load();

        $this->bucket = $_ENV['S3_BUCKET_NAME'];
        $this->cloudfrontUrl = $_ENV['CLOUDFRONT_URL'];

        $this->s3 = new S3Client([
            'version' => 'latest',
            'region'  => $_ENV['AWS_REGION'],
            'credentials' => [
                'key'    => $_ENV['AWS_ACCESS_KEY_ID'],
                'secret' => $_ENV['AWS_SECRET_ACCESS_KEY'],
            ],
        ]);
    }

    public function uploadFile($filePath, $key)
    {
        try {
            $result = $this->s3->putObject([
                'Bucket' => $this->bucket,
                'Key'    => $key,
                'SourceFile' => $filePath,
            ]);

            return $result['ObjectURL'];
        } catch (AwsException $e) {
            echo "Error uploading file: " . $e->getMessage();
            return false;
        }
    }

    public function getFileUrl($key)
    {
        return $this->cloudfrontUrl . $key;
    }

    public function uploadFromFiles($file, $key)
    {
        try {
            $result = $this->s3->putObject([
                'Bucket' => $this->bucket,
                'Key'    => $key,
                'Body'   => fopen($file['tmp_name'], 'rb'),
                'ACL'    => 'public-read', // Optional: for public access
            ]);

            return $result['ObjectURL'];
        } catch (AwsException $e) {
            echo "Error uploading file: " . $e->getMessage();
            return false;
        }
    }
}

Exemplo de Uso

Agora, você pode usar a classe S3Manager para fazer o upload de arquivos, tanto a partir de um caminho no sistema de arquivos quanto diretamente do $_FILES:

<?php

require 'vendor/autoload.php';

use App\S3Manager;

$s3Manager = new S3Manager();

// Exemplo de upload de um arquivo existente
$filePath = '/path/to/your/file.txt';
$key = 'uploads/file.txt';
$uploadUrl = $s3Manager->uploadFile($filePath, $key);

if ($uploadUrl) {
    echo "File uploaded successfully. URL: " . $uploadUrl . PHP_EOL;
}

// Exemplo de upload via $_FILES
if ($_FILES) {
    $file = $_FILES['uploaded_file'];
    $key = 'uploads/' . basename($file['name']);
    $uploadUrl = $s3Manager->uploadFromFiles($file, $key);

    if ($uploadUrl) {
        echo "File uploaded successfully via $_FILES. URL: " . $uploadUrl . PHP_EOL;
    }
}

// Exemplo de obtenção da URL do arquivo via CloudFront
$fileUrl = $s3Manager->getFileUrl($key);
echo "File URL via CloudFront: " . $fileUrl . PHP_EOL;

Vantagem de Configurar uma Distribuição do CloudFront para S3

Ao utilizar o Amazon S3 para armazenar seus arquivos, cada acesso a esses arquivos gera custos. Dependendo do volume de acessos, isso pode se tornar significativo. Uma maneira eficiente de reduzir esses custos e ainda melhorar a performance de sua aplicação é configurando uma distribuição do Amazon CloudFront.

O CloudFront é uma Content Delivery Network (CDN) da AWS que oferece várias vantagens:

• Redução de Custos: Enquanto o S3 cobra por cada acesso aos seus arquivos, o CloudFront oferece um custo por acesso menor, o que pode resultar em economias consideráveis, especialmente para sites ou aplicações com alto tráfego.
• Cacheamento: O CloudFront armazena em cache os arquivos em diversos pontos de presença (PoPs) ao redor do mundo. Isso não só reduz a latência, tornando o acesso mais rápido para os usuários, como também diminui a quantidade de requisições diretamente ao S3, economizando ainda mais nos custos de acesso.
• Melhoria de Performance: Com os arquivos sendo servidos a partir de locais mais próximos dos usuários finais, o tempo de carregamento é significativamente reduzido, proporcionando uma experiência de usuário mais fluida.

Ao configurar o CloudFront para distribuir os arquivos armazenados no S3, você não só economiza, mas também melhora a performance e a escalabilidade da sua aplicação.

Considerações Finais

Ao configurar seu projeto PHP para interagir com o Amazon S3 e CloudFront, você está construindo uma solução escalável e segura para gerenciar arquivos na nuvem. O uso de variáveis de ambiente e a abordagem modular ajudam a manter a flexibilidade e a segurança do seu sistema. Além disso, a possibilidade de fazer uploads diretamente via $_FILES facilita a integração em sistemas que recebem arquivos de formulários HTML.

Se você está começando a trabalhar com AWS ou deseja melhorar seu sistema atual, essa solução pode ser o ponto de partida ideal, especialmente ao considerar as vantagens de utilizar o CloudFront para acessar seus arquivos no S3.

Gostou do conteúdo? Deixe seu comentário abaixo e compartilhe com outros desenvolvedores que podem se beneficiar deste tutorial!