🌐 Hospedar APIs na MozHost

Aprenda a fazer deploy de APIs REST na MozHost usando Node.js (Express.js, Fastify) ou Python (Flask, FastAPI).

Frameworks Suportados

A MozHost suporta os principais frameworks para construção de APIs. Escolha o que melhor se adapta ao seu projecto:

🟢

Express.js

Node.js — Mais popular

⚡

Fastify

Node.js — Alta performance

🐍

Flask

Python — Leve e flexível

🚀

FastAPI

Python — Moderno e rápido

Passo a Passo para Fazer Deploy de uma API

Crie um Container

Acesse o painel da MozHost e crie um novo container. Escolha Node.js para Express/Fastify ou Python para Flask/FastAPI.

💡 Dica: Veja o guia completo em Criar seu Primeiro Container.

Prepare o seu Código

Certifique-se de que o seu projecto tem um ficheiro de entrada (ex: index.js, app.py) e as dependências listadas (package.json ou requirements.txt).

Faça Upload do Código

Envie os ficheiros do seu projecto para o container através do painel ou usando a CLI da MozHost.

Configure as Variáveis de Ambiente

Adicione as variáveis necessárias (PORT, credenciais de banco de dados, chaves de API, etc.) no painel do container.

Inicie o Container

Clique em "Iniciar" no painel. O sistema vai instalar as dependências automaticamente e executar a sua API. Acesse-a pelo URL/domínio do container.

Exemplo: API REST com Express.js

Aqui está um exemplo completo de uma API REST simples usando Express.js com rotas de CRUD:

package.json:

{
  "name": "minha-api",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "start": "node index.js"
  },
  "dependencies": {
    "express": "^4.18.2",
    "cors": "^2.8.5",
    "helmet": "^7.1.0"
  }
}

index.js:

const express = require('express');
const cors = require('cors');
const helmet = require('helmet');

const app = express();
const PORT = process.env.PORT || 3000;

// Middlewares
app.use(helmet());
app.use(cors());
app.use(express.json());

// Dados em memória (substitua por um banco de dados)
let produtos = [
  { id: 1, nome: 'Capulana', preco: 350 },
  { id: 2, nome: 'Maheu', preco: 50 },
];

// GET - Listar todos os produtos
app.get('/api/produtos', (req, res) => {
  res.json({ success: true, data: produtos });
});

// GET - Buscar produto por ID
app.get('/api/produtos/:id', (req, res) => {
  const produto = produtos.find(p => p.id === Number(req.params.id));
  if (!produto) {
    return res.status(404).json({ success: false, message: 'Produto não encontrado' });
  }
  res.json({ success: true, data: produto });
});

// POST - Criar produto
app.post('/api/produtos', (req, res) => {
  const { nome, preco } = req.body;
  const novoProduto = { id: produtos.length + 1, nome, preco };
  produtos.push(novoProduto);
  res.status(201).json({ success: true, data: novoProduto });
});

// PUT - Actualizar produto
app.put('/api/produtos/:id', (req, res) => {
  const index = produtos.findIndex(p => p.id === Number(req.params.id));
  if (index === -1) {
    return res.status(404).json({ success: false, message: 'Produto não encontrado' });
  }
  produtos[index] = { ...produtos[index], ...req.body };
  res.json({ success: true, data: produtos[index] });
});

// DELETE - Remover produto
app.delete('/api/produtos/:id', (req, res) => {
  produtos = produtos.filter(p => p.id !== Number(req.params.id));
  res.json({ success: true, message: 'Produto removido' });
});

app.listen(PORT, () => {
  console.log(`API rodando na porta ${PORT}`);
});

Exemplo: API REST com Flask

Um exemplo equivalente usando Flask (Python):

requirements.txt:

flask==3.0.0
flask-cors==4.0.0

app.py:

import os
from flask import Flask, jsonify, request
from flask_cors import CORS

app = Flask(__name__)
CORS(app)

produtos = [
    {"id": 1, "nome": "Capulana", "preco": 350},
    {"id": 2, "nome": "Maheu", "preco": 50},
]

@app.route("/api/produtos", methods=["GET"])
def listar_produtos():
    return jsonify({"success": True, "data": produtos})

@app.route("/api/produtos/<int:id>", methods=["GET"])
def buscar_produto(id):
    produto = next((p for p in produtos if p["id"] == id), None)
    if not produto:
        return jsonify({"success": False, "message": "Produto não encontrado"}), 404
    return jsonify({"success": True, "data": produto})

@app.route("/api/produtos", methods=["POST"])
def criar_produto():
    dados = request.get_json()
    novo = {"id": len(produtos) + 1, "nome": dados["nome"], "preco": dados["preco"]}
    produtos.append(novo)
    return jsonify({"success": True, "data": novo}), 201

@app.route("/api/produtos/<int:id>", methods=["DELETE"])
def remover_produto(id):
    global produtos
    produtos = [p for p in produtos if p["id"] != id]
    return jsonify({"success": True, "message": "Produto removido"})

if __name__ == "__main__":
    port = int(os.environ.get("PORT", 3000))
    app.run(host="0.0.0.0", port=port)

Configurar Variáveis de Ambiente

As variáveis de ambiente permitem que você configure a sua API sem alterar o código. Use-as para guardar credenciais, portas e configurações sensíveis.

💡 Como adicionar: No painel do container, acesse a aba "Variáveis de Ambiente" e adicione as variáveis no formato CHAVE=VALOR.

Exemplo de variáveis comuns:

PORT=3000
DATABASE_URL=mysql://user:senha@host:porta/database
API_KEY=sua_chave_secreta
NODE_ENV=production
JWT_SECRET=minha_chave_jwt_segura

Acessando no código (Node.js):

const port = process.env.PORT || 3000;
const dbUrl = process.env.DATABASE_URL;
const apiKey = process.env.API_KEY;

Acessando no código (Python):

import os

port = int(os.environ.get("PORT", 3000))
db_url = os.environ.get("DATABASE_URL")
api_key = os.environ.get("API_KEY")

Conectar a um Banco de Dados

Para conectar a sua API a um banco de dados, primeiro crie um database na MozHost e use as credenciais fornecidas.

Node.js com MySQL (mysql2):

const mysql = require('mysql2/promise');

const pool = mysql.createPool({
  host: process.env.DB_HOST,
  port: process.env.DB_PORT,
  user: process.env.DB_USER,
  password: process.env.DB_PASSWORD,
  database: process.env.DB_NAME,
});

app.get('/api/produtos', async (req, res) => {
  const [rows] = await pool.query('SELECT * FROM produtos');
  res.json({ success: true, data: rows });
});

Node.js com MongoDB (mongoose):

const mongoose = require('mongoose');

mongoose.connect(process.env.DATABASE_URL);

const ProdutoSchema = new mongoose.Schema({
  nome: String,
  preco: Number,
});

const Produto = mongoose.model('Produto', ProdutoSchema);

app.get('/api/produtos', async (req, res) => {
  const produtos = await Produto.find();
  res.json({ success: true, data: produtos });
});

Python com MySQL (pymysql):

import os
import pymysql

connection = pymysql.connect(
    host=os.environ.get("DB_HOST"),
    port=int(os.environ.get("DB_PORT", 3306)),
    user=os.environ.get("DB_USER"),
    password=os.environ.get("DB_PASSWORD"),
    database=os.environ.get("DB_NAME"),
)

@app.route("/api/produtos", methods=["GET"])
def listar_produtos():
    with connection.cursor(pymysql.cursors.DictCursor) as cursor:
        cursor.execute("SELECT * FROM produtos")
        produtos = cursor.fetchall()
    return jsonify({"success": True, "data": produtos})

Acessar a API pelo Domínio

Após o deploy, a sua API estará disponível automaticamente através do subdomínio do container:

URL da sua API:

https://nome-do-container.mozhost.app

Exemplos de endpoints:

GET https://minha-api.mozhost.app/api/produtos

POST https://minha-api.mozhost.app/api/produtos

DELETE https://minha-api.mozhost.app/api/produtos/1

✅ Domínio personalizado: Você também pode configurar um domínio próprio (ex: api.meusite.co.mz) nas configurações do container, apontando o DNS para a MozHost.

Dicas e Boas Práticas

✅

Use a variável PORT do ambiente

Sempre leia a porta de process.env.PORT (Node.js) ou os.environ.get("PORT") (Python). A MozHost define essa variável automaticamente.

✅

Configure o CORS correctamente

Se o seu frontend acessa a API de outro domínio, habilite o CORS. Em Node.js use o pacote cors, em Python use flask-cors.

// Node.js - Permitir origens específicas
const cors = require('cors');
app.use(cors({
  origin: ['https://meusite.co.mz', 'https://www.meusite.co.mz']
}));

✅

Use Helmet para segurança (Node.js)

O helmet adiciona headers de segurança HTTP automaticamente, protegendo contra ataques comuns como XSS e clickjacking.

const helmet = require('helmet');
app.use(helmet());

✅

Nunca exponha credenciais no código

Use sempre variáveis de ambiente para guardar senhas, chaves de API e tokens. Nunca faça commit de ficheiros .env no repositório.

✅

Escute em 0.0.0.0

Em Python (Flask/FastAPI), certifique-se de escutar em 0.0.0.0 e não em 127.0.0.1, para que o container consiga receber pedidos externos.

Próximos Passos

Agora que você sabe como hospedar APIs na MozHost, pode:

✓Criar um container e fazer deploy da sua primeira API

✓Conectar a API a um banco de dados

✓Configurar variáveis de ambiente e domínio personalizado

✓Integrar a API com o Email Service da MozHost

Criar Database →Email Service →