Exemplos em GO Lang e Csharp na utilização de Cloud Functions em aplicações Comerciais.

Para dar continuidade à série de alto nível no RCOTechnolab, a abordagem com Google Cloud Functions (GCF) deve focar em cenários puramente reativos e orientados a eventos (Event-Driven Architecture) [cite: User Summary].

Abaixo estão dois exemplos práticos e comerciais modelados para o ecossistema de funções serverless, seguidos por uma análise sênior de riscos e benefícios [cite: User Summary].

🐹 Exemplo em Go: Webhook de Confirmação de Pagamento (Asaas / Stripe)

Em plataformas de e-commerce ou sistemas de agendamento, quando um pagamento é aprovado, o gateway envia um HTTP POST (Webhook). O Cloud Functions é ideal aqui: ele acorda, valida o token, enfileira o processo e morre, cobrando apenas pelos milissegundos de execução.

package paymentwebhook

import (
	"encoding/json"
	"fmt"
	"net/http"
	"github.com/GoogleCloudPlatform/functions-framework-go/functions"
)

type PaymentEvent struct {
	ID     string  `json:"id"`
	Status string  `json:"status"`
	Value  float64 `json:"value"`
}

func init() {
	// Registra a função no framework do Google Cloud Functions
	functions.HTTP("HandlePaymentWebhook", handlePaymentWebhook)
}

func handlePaymentWebhook(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		http.Error(w, "Metodo nao permitido", http.StatusMethodNotAllowed)
		return
	}

	var event PaymentEvent
	if err := json.NewDecoder(r.Body).Decode(&event); err != nil {
		http.Error(w, "Payload invalido", http.StatusBadRequest)
		return
	}

	// Cenário Comercial: Se o pagamento foi aprovado, dispara evento
	if event.Status == "APPROVED" {
		fmt.Printf("Sucesso: Pagamento %s de R$ %.2f confirmado.\n", event.ID, event.Value)
		// Aqui você enviaria uma mensagem para o Pub/Sub para o sistema processar a liberação
	}

	w.WriteHeader(http.StatusOK)
	w.Write([]byte(`{"status":"success"}`))
}

🔷 Exemplo em .NET (C#): Redimensionador de Imagens de Perfil (Cloud Storage Trigger)

No .NET Core, em vez de um trigger HTTP, podemos usar um gatilho de infraestrutura do Google Cloud Storage. Quando o usuário faz o upload de uma foto de perfil, a função é disparada automaticamente para gerar o thumbnail.

using CloudNative.CloudEvents;
using Google.Cloud.Functions.Framework;
using Google.Events.Protobuf.Cloud.Storage.V1;
using Microsoft.Extensions.Logging;
using System.Threading;
using System.Threading.Tasks;

namespace ProfilePictureResizer
{
    // Vincula a função ao evento de criação de objeto no Cloud Storage
    public class ImageResizerFunction : ICloudEventFunction<StorageObjectData>
    {
        private readonly ILogger<ImageResizerFunction> _logger;

        public ImageResizerFunction(ILogger<ImageResizerFunction> logger) =>
            _logger = logger;

        public Task HandleAsync(CloudEvent cloudEvent, StorageObjectData data, CancellationToken cancellationToken)
        {
            _logger.LogInformation($"Novo arquivo detectado: {data.Name} no Bucket: {data.Bucket}");

            // Validar se é uma imagem (ex: png, jpg)
            if (data.ContentType.StartsWith("image/"))
            {
                _logger.LogInformation($"Iniciando redimensionamento de {data.Name} para 150x150px...");
                
                // 1. Baixar o stream do arquivo usando HttpClient ou SDK do Google Cloud
                // 2. Processar a imagem usando uma biblioteca leve (ex: SixLabors.ImageSharp)
                // 3. Salvar o thumbnail de volta em um bucket de produção
            }

            return Task.CompletedTask;
        }
    }
}

📊 Análise Arquitetural para o Blog

🟢 Benefícios da Abordagem FaaS

Custo Zero em Ociosidade: Se o seu sistema comercial não receber uploads de fotos ou webhooks de madrugada, você paga literalmente zero pela computação nesse período.
Escalabilidade Granular e Infinita: Se houver uma enxurrada de 10.000 pagamentos no mesmo minuto (ex: uma Black Friday), o Google Cloud cria instâncias isoladas da sua função em paralelo para absorver o pico instantaneamente.
Foco Total no Código: O desenvolvedor não precisa configurar servidores Web (Kestrel no .NET ou rotas complexas), Dockerfiles, mapeamento de portas ou atualizações de segurança do Sistema Operacional.

🔴 Riscos e Desvantagens da Abordagem FaaS

O Gargalo do Banco de Dados (Connection Pooling): Como cada requisição paralela pode criar uma nova instância da função, se você tiver 1.000 funções acordando ao mesmo tempo e tentando abrir uma conexão direta com um banco relacional tradicional (como PostgreSQL ou SQL Server), você vai derrubar o banco por excesso de conexões. Mitigação: É obrigatório usar um Connection Pooler (como PgBouncer) ou APIs de dados baseadas em HTTP (Supabase / Firestore).
Cold Starts (Início Frio): Se a função passar muito tempo sem ser usada, o Google desarma o container interno. A próxima requisição demorará alguns segundos para responder porque o ambiente precisará ser inicializado do zero. Mitigação: O Go sofre muito menos com isso por gerar binários nativos levíssimos; já o .NET pode ter um Cold Start ligeiramente maior, exigindo técnicas de Pre-warming ou configuração de instâncias mínimas (o que anula o custo zero).
Vendor Lock-in: O código escrito para o Google Cloud Functions fica acoplado aos pacotes e assinaturas do framework do Google (Google.Cloud.Functions.Framework ou functions-framework-go). Migrar essa mesma função para a AWS Lambda exigirá refatoração na estrutura de entrada e saída do código.