---
title: "Laboratório: escolher um modelo e calcular o custo de uma carga de trabalho"
domain: cloud-computing
level: beginner
duration: "35 min"
cost: "gratuito"
environment: "o seu próprio computador (Linux, macOS ou Windows com WSL2) com Python 3.9 ou posterior; sem conta em nenhuma cloud"
lang: pt
source_hash: f0c9200192c0
---

# Laboratório: escolher um modelo e calcular o custo de uma carga de trabalho

## Objetivo
Atuar como consultor de TI de uma pequena organização. Primeiro, decidir quem trata de cada parte de um sistema em cada modelo de serviço. Depois, escolher o modelo adequado para quatro cargas de trabalho. Por fim, executar um breve script em Python que mostra quando alugar servidores é mais barato do que comprá-los, e quando não é.

## Objetivos
- Indicar quem gere cada camada (o cliente ou o fornecedor) em on-premises, IaaS, PaaS e SaaS.
- Escolher um modelo de serviço e um modelo de implementação para uma carga de trabalho e justificar a escolha.
- Comparar o custo mensal de ter servidores próprios com o de os alugar, para uma carga com muita atividade e depois pouca, e para uma carga constante.

## Pré-requisitos
- Python 3.9 ou posterior (`python3 --version`). Só é necessário executar um script; não é preciso saber Python.
- Um terminal e um editor de texto.
- Nenhuma conta de cloud, nenhum dado de pagamento e nenhum acesso à rede.
- [A lição Fundamentos da cloud](lesson.pt.md) deste módulo.

> [!WARNING]
> Nada neste laboratório toca numa cloud real. Todos os preços são **números redondos inventados para fins didáticos**, e não a tabela de preços de qualquer fornecedor. Não os utilize para uma compra real.

## Arquitetura
![Cenário do laboratório. À esquerda, a organização inventada Riverside Vet Group com quatro cargas de trabalho: correio e calendário do pessoal, portal de marcações online, app de gestão da clínica e miniaturas de fotografias. Uma seta com a etiqueta "decide-se" leva a três passos à direita: passo 1, quem gere o quê, respondido no papel; passo 2, escolher um modelo para cada carga, também no papel; e os passos 3 e 4, o script cost.py na pasta ~/cloud-lab-01 do computador, que compara comprar servidores com alugá-los.](../../../assets/diagrams/cloud-lab-architecture.pt.svg)

*Figura 1. Os passos 1 e 2 são exercícios de reflexão; os passos 3 e 4 executam um pequeno script.*

## Passos

### Passo 1 — Quem gere o quê? (8 min)
A lição mostrou que o modelo de serviço decide quem trata de cada camada. Teste-se. Em papel ou num ficheiro de texto, responda a cada pergunta com **cliente** ou **fornecedor**:

1. Em **IaaS**, quem instala as atualizações de segurança do sistema operativo da máquina virtual?
2. Em **IaaS**, quem substitui um disco avariado do servidor físico?
3. Em **PaaS**, quem mantém atualizado o ambiente de execução (por exemplo, a versão do Python)?
4. Em **PaaS**, quem corrige um erro no código da aplicação?
5. Em **SaaS** (por exemplo, um serviço de correio web), quem corrige um erro da aplicação?
6. Em **SaaS**, quem decide que colaboradores podem ler as caixas de correio da empresa?

Tente responder a todas antes de abrir as respostas.

<details>
<summary>Mostrar as respostas</summary>

| # | Resposta | Porquê |
|---|---|---|
| 1 | Cliente | Em IaaS aluga-se uma máquina virtual; tudo o que está do sistema operativo para cima é do cliente. |
| 2 | Fornecedor | O hardware e o centro de dados são sempre do fornecedor num modelo de cloud. |
| 3 | Fornecedor | Em PaaS o cliente só fornece o seu código; a plataforma por baixo é do fornecedor. |
| 4 | Cliente | É o código do cliente. |
| 5 | Fornecedor | Em SaaS usa-se uma aplicação pronta; o fornecedor constrói-a e corrige-a. |
| 6 | Cliente | Os dados e o controlo de acesso ficam com o cliente em **todos** os modelos. |

A visão completa, como na lição:

| Camada | On-premises | IaaS | PaaS | SaaS |
|---|---|---|---|---|
| Dados e controlo de acesso | Cliente | Cliente | Cliente | Cliente |
| Aplicação | Cliente | Cliente | Cliente | Fornecedor |
| Sistema operativo e ambiente de execução | Cliente | Cliente | Fornecedor | Fornecedor |
| Servidores, armazenamento e centro de dados | Cliente | Fornecedor | Fornecedor | Fornecedor |

Quanto mais para a direita, menos se gere. A primeira linha nunca muda.

</details>

### Passo 2 — Escolher um modelo para cada carga de trabalho (10 min)
**O cenário.** O Riverside Vet Group é uma organização inventada: 4 clínicas veterinárias, 60 colaboradores e uma pessoa de TI. A administração quer "passar para a cloud" e consulta-o sobre quatro cargas de trabalho:

| Carga de trabalho | Dados |
|---|---|
| Correio e calendário do pessoal | Toda a gente precisa. Nada de especial. Ninguém quer gerir um servidor de correio. |
| Portal de marcações online | Uma aplicação web escrita pelo programador do grupo. Com muita atividade de manhã, quase inativa à noite. |
| App de gestão da clínica | Comprada a um fabricante que só a suporta numa versão específica do Windows Server. Não pode ser alterada. |
| Miniaturas de fotografias | Quando é carregada a fotografia de um animal, é preciso gerar uma versão pequena. Uns segundos de trabalho e depois nada durante algum tempo. |

Para cada carga de trabalho, faça estas três perguntas **por ordem** e pare no primeiro "sim":

1. Podemos simplesmente usar um produto pronto? → **SaaS**
2. É código nosso que só corre por um instante quando algo acontece? → **FaaS** · É código nosso que corre o tempo todo? → **PaaS**
3. Precisamos de controlar o sistema operativo? → **IaaS**

Anote a escolha e uma frase de justificação para cada carga de trabalho.

<details>
<summary>Mostrar um conjunto de respostas válido</summary>

| Carga de trabalho | Modelo | Motivo |
|---|---|---|
| Correio e calendário do pessoal | SaaS | Uma necessidade comum com bons produtos prontos; o fornecedor gere e atualiza tudo. |
| Portal de marcações online | PaaS | Código nosso, a correr o dia todo; não queremos atualizar servidores. |
| App de gestão da clínica | IaaS | O fabricante exige um sistema operativo específico, pelo que precisamos de o controlar. |
| Miniaturas de fotografias | FaaS | Tarefas curtas que começam quando chega uma fotografia; só se paga enquanto corre. |

Outras respostas podem estar certas se o motivo for bom. Por exemplo, o portal de marcações em IaaS também funciona, mas então a equipa tem de atualizar os servidores.

</details>

**Mais uma decisão: o modelo de implementação.** O grupo guarda também imagens de raios X que, por lei, têm de permanecer dentro do país. Isso obriga a uma nuvem privada?

<details>
<summary>Mostrar a resposta</summary>

Não necessariamente. A lei exige uma **localização** dentro do país, não o próprio edifício. Uma região de nuvem pública dentro do país cumpre-a. Uma nuvem privada também, mas custa mais a construir e a operar. Convém ler o que uma regra realmente exige antes de escolher.

</details>

### Passo 3 — Comparar ter e alugar (10 min)
O portal de marcações tem muita atividade durante duas horas todas as manhãs e fica tranquilo no resto do dia. Deve o grupo comprar servidores ou alugá-los? Crie uma pasta e um pequeno script:

```bash
mkdir ~/cloud-lab-01
cd ~/cloud-lab-01
cat > cost.py <<'EOF'
# Owning servers versus renting them, for one month.
# All prices are invented, round numbers for teaching.

OWN_PER_SERVER_MONTH = 100   # buying a server, spread over its life, plus power: EUR per month
RENT_PER_SERVER_HOUR = 0.20  # renting one similar server: EUR per hour
DAYS = 30

def compare(name, busy_servers, busy_hours, quiet_servers):
    quiet_hours = 24 - busy_hours
    server_hours = (busy_servers * busy_hours + quiet_servers * quiet_hours) * DAYS
    own = busy_servers * OWN_PER_SERVER_MONTH    # you must own enough servers for the busiest hour
    rent = server_hours * RENT_PER_SERVER_HOUR   # you rent only what each hour needs
    print(f"{name}: own {own:.0f} EUR, rent {rent:.0f} EUR -> cheaper: {'rent' if rent < own else 'own'}")

compare("Booking portal", busy_servers=10, busy_hours=2, quiet_servers=2)
compare("Steady service", busy_servers=6, busy_hours=24, quiet_servers=6)
EOF
python3 cost.py
```

Resultado esperado:
```text
Booking portal: own 1000 EUR, rent 384 EUR -> cheaper: rent
Steady service: own 600 EUR, rent 864 EUR -> cheaper: own
```

Como saem os números:

- **Portal de marcações.** Precisa de 10 servidores durante 2 horas por dia e de 2 servidores nas outras 22. Se os **comprar**, tem de comprar os suficientes para o momento de maior atividade: 10 servidores × 100 EUR = 1000 EUR por mês, ainda que 8 deles estejam inativos a maior parte do dia. Se os **alugar**, paga só o que cada hora utiliza: (10 × 2 + 2 × 22) = 64 horas de servidor por dia × 30 dias × 0,20 EUR = 384 EUR. Alugar ganha.
- **Serviço constante.** Precisa de 6 servidores o dia todo, todos os dias. Comprá-los custa 6 × 100 = 600 EUR. Alugá-los custa 6 × 24 × 30 × 0,20 = 864 EUR. Sem horas tranquilas em que poupar, os servidores próprios estão sempre ocupados e **ter os servidores ganha**.

Este é o compromisso entre CapEx e OpEx da lição: comprar (CapEx) significa pagar sempre pelo pico; alugar (OpEx) acompanha a carga.

### Passo 4 — Alterar um preço e prever (5 min)
Suponha que o preço do aluguer desce para 0,10 EUR por hora. Antes de executar seja o que for, adivinhe: qual das duas respostas vai mudar?

Abra `cost.py` no editor de texto e altere esta linha:

```text
RENT_PER_SERVER_HOUR = 0.20
```

para:

```text
RENT_PER_SERVER_HOUR = 0.10
```

Guarde o ficheiro e execute-o de novo:

```bash
python3 cost.py
```

Resultado esperado:
```text
Booking portal: own 1000 EUR, rent 192 EUR -> cheaper: rent
Steady service: own 600 EUR, rent 432 EUR -> cheaper: rent
```

Acertou? O portal de marcações já era mais barato de alugar. O que muda é o serviço constante: a metade do preço, alugá-lo o dia todo (432 EUR) custa agora menos do que ter os servidores (600 EUR). A resposta a "comprar ou alugar?" depende de duas coisas: **quanto a carga varia** e **os preços**. Convém verificar ambas antes de decidir.

## Verificação
Volte a pôr o preço em `0.20`, guarde e execute o script mais uma vez:

```bash
python3 cost.py
```

O laboratório está concluído com êxito se o resultado coincidir com o do Passo 3: alugar é mais barato para o portal de marcações e ter os servidores é mais barato para o serviço constante.

## Resolução de problemas
| Sintoma | Causa provável | Solução |
|---|---|---|
| `python3: command not found` | O Python não está instalado, ou chama-se `python` | Instalar o Python 3.9 ou posterior; no Windows, usar o WSL2 ou instalá-lo a partir de python.org e executar `python` em vez de `python3` |
| `IndentationError` ou `SyntaxError` | Uma linha perdeu os espaços do início, ou foi colada só em parte | Apagar `cost.py` e executar de novo todo o bloco do Passo 3 |
| `mkdir: cannot create directory ... File exists` | O Passo 3 já foi executado uma vez | Não há problema: executar `cd ~/cloud-lab-01` e continuar |
| Os números diferem dos do laboratório | Ainda há um preço alterado em `cost.py` | Repor `RENT_PER_SERVER_HOUR = 0.20` e `OWN_PER_SERVER_MONTH = 100` |

## Desafio (opcional)
1. O portal de marcações lança uma campanha de marketing e passa a ter muita atividade 12 horas por dia em vez de 2. Altere `busy_hours=2` para `busy_hours=12` no portal de marcações e adivinhe o resultado antes de o executar.
2. Acrescente uma terceira linha com um exemplo próprio, como o sítio web de uma escola que só tem muita atividade durante o período letivo, e decida se compra ou aluga.

## Limpeza
O laboratório criou uma pasta no diretório pessoal e mais nada. Remova-a:

```bash
cd ~
rm -r ~/cloud-lab-01
```

## O que aprendeu
- Quem gere o quê depende do modelo de serviço, mas os dados e quem lhes pode aceder são sempre da responsabilidade do cliente.
- Para escolher um modelo de serviço, perguntar por ordem: existe um produto pronto (SaaS)? É código nosso (FaaS ou PaaS)? Precisamos do sistema operativo (IaaS)?
- Uma regra legal sobre localização pode ser cumprida por uma região de nuvem pública no país certo; convém ler o que a regra realmente exige.
- Ter servidores próprios significa pagar sempre pela hora de maior atividade. Alugar acompanha a carga, pelo que ganha quando a carga varia muito, e ter os servidores pode ganhar quando a carga é constante e elevada.
