Escalabilidade e performance: projetar sistemas que sobrevivem ao crescimento

Por que sistemas que funcionam perfeitamente em desenvolvimento travam em produção?

Um sistema de e-commerce funciona impecavelmente durante os testes: 50 usuários simultâneos, tempo de resposta abaixo de 200ms, zero erros. Chega a Black Friday — 50.000 usuários simultâneos — e o sistema para. Completamente. O problema não estava no código. Estava na arquitetura de escalabilidade, que nunca foi projetada para crescer.

Escalabilidade e performance não são otimizações de último minuto. São decisões arquiteturais tomadas no início — ou pagas com juros altos em produção. Esta aula fecha o ciclo iniciado em [SIS]ANO2C2B2S8A1 (arquiteturas) e [SIS]ANO2C2B2S8A2 (design patterns): agora vamos entender como os sistemas crescem — e por que alguns sobrevivem a esse crescimento enquanto outros colapsam.

Como ensinar escalabilidade no ensino médio técnico com recursos limitados?

A aula [SIS]ANO2C2B2S8A3 fecha a unidade de arquitetura de back-end com uma síntese prática. Em 45 minutos, com Google Colab como único ambiente necessário, os estudantes implementam uma loja on-line monolítica, refatoram para microsserviços e analisam o impacto em escalabilidade e performance. O conceito de auto-scaling, que em produção exige Kubernetes e AWS, é representado por um loop Python que simula carga variável — abstração precisa sem perda conceitual.

Quais são as dimensões de escalabilidade e performance em cada arquitetura?

Estratégias de otimização: o que vai além da arquitetura

Como implementar e comparar as duas arquiteturas em Python?

Passo 1 — Loja on-line monolítica

# Monolito — todas as responsabilidades centralizadas
class OnlineStore:
    def __init__(self):
        self.users = []; self.products = []; self.orders = []

    def register_user(self, user): self.users.append(user)
    def add_product(self, product): self.products.append(product)

    def place_order(self, user, product):
        if product in self.products:
            self.orders.append((user, product))
            return "Order placed successfully"
        return "Product not available"

# Teste de carga simulada — 100 pedidos consecutivos
store = OnlineStore()
store.register_user("Alice"); store.add_product("Laptop")
for i in range(100):
    print(store.place_order("Alice", "Laptop"))

Passo 2 — Refatoração para microsserviços com análise de performance

# Microsserviços — cada responsabilidade isolada e escalável
class UserService:
    def __init__(self): self.users = []
    def register_user(self, user): self.users.append(user)

class ProductService:
    def __init__(self): self.products = []
    def add_product(self, product): self.products.append(product)
    def check_availability(self, product):
        return product in self.products

class OrderService:
    def __init__(self): self.orders = []
    def place_order(self, user, product, product_service):
        if product_service.check_availability(product):
            self.orders.append((user, product))
            return "Order placed successfully"
        return "Product not available"

# Teste de carga simulada — 100 pedidos
user_svc = UserService(); prod_svc = ProductService(); ord_svc = OrderService()
user_svc.register_user("Alice"); prod_svc.add_product("Laptop")
for i in range(100):
    print(ord_svc.place_order("Alice", "Laptop", prod_svc))

Como esses conceitos aparecem em um cenário pedagógico real?

Perguntas frequentes sobre escalabilidade e performance

Escalabilidade como mentalidade de engenheiro, não de programador

A diferença entre um programador e um engenheiro de software não está na quantidade de código que conhece. Está em saber, antes de escrever a primeira linha, como aquele sistema vai se comportar com dez vezes mais usuários, com um serviço falhando, com um pico de acesso inesperado. Escalabilidade e performance são as perguntas que engenheiros fazem antes de codificar — e que programadores descobrem tarde demais em produção.