Ao utilizar o Gemma-3 Pixel Studio, uma limitação comum é o armazenamento temporário das imagens na memória. Elas são descartadas após a sessão, o que inibe a colaboração eficiente em projetos que requerem reutilização frequente de recursos visuais, como designs de produto ou ilustrações compartilhadas em equipe. Integrar um serviço de armazenamento de objetos robusto, como o MinIO, soluciona isso ao fornecer cache persistente e controle de versões.

O MinIO é uma solução de armazenamento de objetos compatível com S3, ideal para implantações autogeridas. Sua leveza e API padronizada o tornam uma escolha sólida para adicionar capacidades de gerenciamento de arquivo ao Pixel Studio.

Funcionalidades-Chave da Implementação

A integração visa prover:

• Cache Automático: Uploads de imagens são salvos automaticamente no bucket MinIO.
• Recuperação Rápida: Um painel lateral permite buscar e reutilizar imagens do histórico.
• Versionamento Simples: Associação de metadados (projeto, tag de versão) durante o upload.
• Compartilhamento em Equipe: Acesso concorrente a um repositório centralizado.

Configuração do Ambiente

Assegure a instalação das dependências necessárias e do servidor MinIO:

pip install minio streamlit python-dotenv

Para iniciar o MinIO via Docker:

docker run -p 9000:9000 -p 9001:9001 \
  -v /caminho/para/dados:/data \
  minio/minio server /data --console-address ":9001"

As credenciais padrão estão disponíveis no console web (localhost:9001). Recomenda-se criar chaves de acesso dedicadas.

Módulo de Gerenciamento MinIO

Crie um módulo Python (storage_service.py) para encapsular as operações com o MinIO:

import hashlib
import os
from datetime import datetime
from minio import Minio
from minio.error import S3Error


class StorageClient:
    def __init__(self, endpoint, access_key, secret_key, bucket, secure=False):
        self.client = Minio(endpoint, access_key=access_key, secret_key=secret_key, secure=secure)
        self.bucket_name = bucket
        self._ensure_bucket()

    def _ensure_bucket(self):
        if not self.client.bucket_exists(self.bucket_name):
            self.client.make_bucket(self.bucket_name)

    def _create_object_key(self, local_path, user_context="global"):
        file_data = open(local_path, 'rb').read()
        content_hash = hashlib.sha256(file_data).hexdigest()[:12]
        base_name = os.path.basename(local_path)
        date_path = datetime.now().strftime("%Y/%m/%d")
        return f"{user_context}/{date_path}/{content_hash}_{base_name}"

    def store_image(self, local_file_path, extra_metadata=None):
        object_key = self._create_object_key(local_file_path)
        base_meta = {
            'x-amz-meta-original-name': os.path.basename(local_file_path),
            'x-amz-meta-upload-timestamp': datetime.utcnow().isoformat()
        }
        if extra_metadata:
            base_meta.update(extra_metadata)

        self.client.fput_object(self.bucket_name, object_key, local_file_path, metadata=base_meta)
        return object_key

    def retrieve_presigned_url(self, object_key, expiry_seconds=3600):
        return self.client.presigned_get_object(self.bucket_name, object_key, expires=expiry_seconds)

    def list_objects_by_prefix(self, prefix="", max_items=100):
        objects = self.client.list_objects(self.bucket_name, prefix=prefix, recursive=True)
        collected = []
        for obj in objects:
            collected.append({
                "key": obj.object_name,
                "size": obj.size,
                "modified": obj.last_modified
            })
            if len(collected) >= max_items:
                break
        return collected

Integração com a Interface do Pixel Studio

Modifique a aplicação Streamlit para incluir os recursos de armazenamento:

import streamlit as st
import tempfile
import os
from storage_service import StorageClient
from dotenv import load_dotenv

load_dotenv()
storage_config = {
    "endpoint": os.getenv("MINIO_ENDPOINT", "localhost:9000"),
    "access_key": os.getenv("MINIO_ACCESS_KEY"),
    "secret_key": os.getenv("MINIO_SECRET_KEY"),
    "bucket": os.getenv("MINIO_BUCKET", "pixel-studio-assets"),
    "secure": os.getenv("MINIO_SECURE", "false").lower() == "true"
}

@st.cache_resource
def get_storage_client():
    return StorageClient(**storage_config)

client = get_storage_client()

st.sidebar.title("Repositório de Imagens")
tab_upload, tab_history = st.sidebar.tabs(["Enviar", "Histórico"])

with tab_upload:
    uploaded_image = st.file_uploader("Carregar imagem", type=["png", "jpg", "jpeg", "webp"])
    if uploaded_image:
        with tempfile.NamedTemporaryFile(delete=False, suffix=f"_{uploaded_image.name}") as tmp:
            tmp.write(uploaded_image.getbuffer())
            temp_path = tmp.name

        user_proj = st.text_input("Nome do Projeto", "Meu Projeto")
        version_info = st.text_input("Versão", "1.0")

        if st.button("Salvar no Repositório"):
            meta = {"x-amz-meta-project": user_proj, "x-amz-meta-version": version_info}
            key = client.store_image(temp_path, meta)
            url = client.retrieve_presigned_url(key)
            st.session_state.current_image = {"key": key, "url": url, "name": uploaded_image.name}
            st.success("Imagem armazenada com sucesso!")
        os.unlink(temp_path)

with tab_history:
    if st.button("Atualizar Lista"):
        st.session_state.history_items = client.list_objects_by_prefix(prefix="global/", max_items=20)

    if "history_items" in st.session_state:
        for item in st.session_state.history_items:
            with st.container(border=True):
                col_img, col_btn = st.columns([3,1])
                with col_img:
                    thumb_url = client.retrieve_presigned_url(item["key"], 300)
                    st.image(thumb_url, width=100)
                with col_btn:
                    if st.button("Usar", key=item["key"]):
                        full_url = client.retrieve_presigned_url(item["key"])
                        st.session_state.current_image = {"key": item["key"], "url": full_url, "name": item["key"].split("/")[-1]}
                        st.rerun()

if "current_image" in st.session_state:
    st.image(st.session_state.current_image["url"], caption=st.session_state.current_image["name"])

Funcionalidades Avançadas

Busca por Metadados

Uma função simples de busca pode filtrar objetos com base nos metadados armazenados:

def search_images_by_keyword(keyword, client_instance):
    all_items = client_instance.list_objects_by_prefix(max_items=500)
    matching_keys = []
    for item in all_items:
        stat = client_instance.client.stat_object(client_instance.bucket_name, item["key"])
        meta = stat.metadata or {}
        values = " ".join(meta.values())
        if keyword.lower() in values.lower() or keyword.lower() in item["key"].lower():
            matching_keys.append(item["key"])
    return matching_keys

Deduplicação Básica

Ao calcular um hash do conteúdo do arquivo, é possível evitar o armazenamento de cópias idênticas, economizando espaço. O método _create_object_key já incorpora parte desta lógica, pois o hash compõe o nome do objeto. Verificar a existência de objetos com o mesmo hash antes do upload torna a deduplicação explícita.

Considerações para Implantação em Produção

Segurança e Configuração

Em produção, utilize HTTPS (secure=True), armazene credenciais em variáveis de ambiente seguras ou em um cofre de segredos, e defina permissões de bucket (IAM) adequadas. Ajuste o tempo de expiração das URLs pré-assinadas conforme a necessidade de exposição dos recursos.

Otimizações de Desempenho

Para cenários com alto volume, considere:

• Geração de Miniaturas: Processar e armazenar versões em baixa resolução das imagens para carregamento rápido nos painéis.
• Paginação: Implementar paginação real nas lsitagens do MinIO para não carregar todos os objetos de uma vez.
• Conexões Persistentes: Reutilizar o cliente Minio dentro da aplicação (como já feito com st.cache_resource).

Esta abordagem transforma o Pixel Studio de uma ferramenta de sessão única em uma plataforma colaborativa com gerenciamento de ativos digitais, aumentando significativamente a produtividade e a organização em projetos visuais contínuos.