Rust

A Guara Cloud suporta totalmente aplicacoes Rust, incluindo frameworks como Actix Web, Axum, Rocket e qualquer outro projeto baseado em Rust. A natureza compilada do Rust produz binarios pequenos e rapidos, ideais para deploys em containers.

Versoes suportadas

As seguintes versoes do Rust sao detectadas automaticamente pelo Buildpack:

• Rust 1.80
• Rust 1.81
• Rust 1.82

A versao e determinada pelo campo rust-version no seu Cargo.toml ou por um arquivo rust-toolchain.toml. Se nenhuma versao for especificada, a ultima versao estavel sera usada.

# Cargo.toml
[package]
name = "my-app"
version = "0.1.0"
edition = "2021"
rust-version = "1.82"

Deploy com Dockerfile

Um build multi-stage e a abordagem recomendada para aplicacoes Rust. Ele compila seu binario em um ambiente Rust completo e depois copia apenas o binario para uma imagem de runtime minima.

FROM rust:1.82 AS builder

WORKDIR /app

COPY Cargo.toml Cargo.lock ./
RUN mkdir src && echo "fn main() {}" > src/main.rs
RUN cargo build --release
RUN rm -rf src

COPY . .
RUN touch src/main.rs
RUN cargo build --release

FROM debian:bookworm-slim

RUN apt-get update && apt-get install -y ca-certificates && rm -rf /var/lib/apt/lists/*

WORKDIR /app
COPY --from=builder /app/target/release/my-app .

EXPOSE 3000

CMD ["./my-app"]

use actix_web::{web, App, HttpServer, HttpResponse};
use std::env;

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let port = env::var("PORT").unwrap_or_else(|_| "3000".to_string());
    let addr = format!("0.0.0.0:{}", port);

    println!("Server starting on {}", addr);

    HttpServer::new(|| {
        App::new()
            .route("/", web::get().to(|| async {
                HttpResponse::Ok().json(serde_json::json!({"status": "ok"}))
            }))
    })
    .bind(&addr)?
    .run()
    .await
}

Deploy com Buildpack

Se o seu repositorio nao contiver um Dockerfile, a Guara Cloud detecta automaticamente seu projeto Rust pela presenca de um arquivo Cargo.toml no diretorio raiz.

O Buildpack vai:

1. Detectar a versao do Rust pelo Cargo.toml ou rust-toolchain.toml
2. Baixar dependencias e armazena-las em cache para builds mais rapidos
3. Compilar sua aplicacao em modo release com cargo build --release
4. Iniciar o binario compilado

Cargo workspaces tambem sao suportados. O Buildpack detecta a estrutura do workspace e compila o binario apropriado.

Configuracao de porta

Sua aplicacao deve escutar na porta configurada nas configuracoes do servico. O padrao e 3000, mas voce pode altera-lo a qualquer momento para corresponder a sua aplicacao.

use std::env;

let port = env::var("PORT").unwrap_or_else(|_| "3000".to_string());
let addr = format!("0.0.0.0:{}", port);

Estrutura de projeto exemplo

my-rust-app/
  Cargo.toml
  Cargo.lock
  src/
    main.rs
    routes/
    models/
  Dockerfile          # opcional — omita para usar Buildpack

Variaveis de ambiente

Estas variaveis de ambiente sao comumente usadas em deploys Rust:

Erros comuns