Deploy a Leptos application

/// Runs on the server. The browser calls it with a POST request to /api/products.
#[server(endpoint = "products")]
pub async fn list_products() -> Result<Vec<String>, ServerFnError> {
    Ok(vec!["Espresso beans".to_string(), "Pour-over kettle".to_string()])
}

/// Renders the home page of your application.
#[component]
fn HomePage() -> impl IntoView {
    // Creates a reactive value to update the button
    let count = RwSignal::new(0);
    let on_click = move |_| *count.write() += 1;
    // Loads the products on the server while it renders the page
    let products = Resource::new(|| (), |_| list_products());

    view! {
        <h1>"Storefront"</h1>
        <button on:click=on_click>"Click Me: " {count}</button>
        <Suspense fallback=|| view! { <p>"Loading products..."</p> }>
            <ul>
                {move || {
                    products
                        .get()
                        .map(|names| {
                            names
                                .unwrap_or_default()
                                .into_iter()
                                .map(|name| view! { <li>{name}</li> })
                                .collect_view()
                        })
                }}
            </ul>
        </Suspense>
    }
}

#[cfg(feature = "ssr")]
#[tokio::main]
async fn main() {
    use axum::{routing::get, Router};
    use leptos::logging::log;
    use leptos::prelude::*;
    use leptos_axum::{generate_route_list, LeptosRoutes};
    use storefront::app::*;

    let conf = get_configuration(None).unwrap();
    let mut addr = conf.leptos_options.site_addr;
    // Sevalla sets PORT: listen on it, on all network interfaces
    if let Ok(port) = std::env::var("PORT") {
        addr = std::net::SocketAddr::from(([0, 0, 0, 0], port.parse().expect("PORT must be a number")));
    }
    let leptos_options = conf.leptos_options;
    // Generate the list of routes in your Leptos App
    let routes = generate_route_list(App);

    let app = Router::new()
        .route("/healthz", get(|| async { "ok" }))
        .leptos_routes(&leptos_options, routes, {
            let leptos_options = leptos_options.clone();
            move || shell(leptos_options.clone())
        })
        .fallback(leptos_axum::file_and_error_handler(shell))
        .with_state(leptos_options);

    log!("listening on http://{}", &addr);
    let listener = tokio::net::TcpListener::bind(&addr).await.unwrap();
    axum::serve(listener, app.into_make_service())
        .with_graceful_shutdown(shutdown_signal())
        .await
        .unwrap();
    log!("server stopped");
}

// Resolves on Ctrl+C or on the SIGTERM that Sevalla sends to stop an instance
#[cfg(feature = "ssr")]
async fn shutdown_signal() {
    use tokio::signal;
    let ctrl_c = async {
        signal::ctrl_c().await.expect("failed to listen for Ctrl+C");
    };
    #[cfg(unix)]
    let terminate = async {
        signal::unix::signal(signal::unix::SignalKind::terminate())
            .expect("failed to listen for SIGTERM")
            .recv()
            .await;
    };
    #[cfg(not(unix))]
    let terminate = std::future::pending::<()>();

    tokio::select! {
        _ = ctrl_c => {},
        _ = terminate => {},
    }
    leptos::logging::log!("shutting down");
}

#[cfg(not(feature = "ssr"))]
pub fn main() {
    // no client-side main function
    // unless we want this to work with e.g., Trunk for pure client-side testing
    // see lib.rs for hydration function instead
}

[toolchain]
channel = "1.99"
targets = ["wasm32-unknown-unknown"]

FROM rust:1.99-slim-trixie AS build
# hadolint ignore=DL3008
RUN apt-get update \
    && apt-get install -y --no-install-recommends binaryen curl \
    && rm -rf /var/lib/apt/lists/* \
    && rustup target add wasm32-unknown-unknown
# cargo-leptos 0.3.11, checked against the SHA-256 checksum of its release
RUN curl -fsSLO https://github.com/leptos-rs/cargo-leptos/releases/download/v0.3.11/cargo-leptos-x86_64-unknown-linux-gnu.tar.gz \
    && echo "1c9cf0e1e3ffae6c8b58d29281d949dab560cea613b80d361f323f93071df7c8  cargo-leptos-x86_64-unknown-linux-gnu.tar.gz" > cargo-leptos.sha256 \
    && sha256sum -c cargo-leptos.sha256 \
    && tar -xzf cargo-leptos-x86_64-unknown-linux-gnu.tar.gz --strip-components=1 -C /usr/local/cargo/bin cargo-leptos-x86_64-unknown-linux-gnu/cargo-leptos \
    && rm cargo-leptos-x86_64-unknown-linux-gnu.tar.gz cargo-leptos.sha256
# The same version as the wasm-bindgen crate in Cargo.lock
RUN cargo install --locked wasm-bindgen-cli@0.2.130
WORKDIR /src
COPY Cargo.toml Cargo.lock ./
# Compile the dependencies alone, so this layer stays cached until Cargo.toml or Cargo.lock changes
RUN mkdir src style public \
    && echo "fn main() {}" > src/main.rs \
    && touch src/lib.rs style/main.css \
    && cargo leptos build --release --cargo-locked \
    && rm -rf src style public target/site
COPY src ./src
COPY style ./style
COPY public ./public
# touch: the copied files are older than the placeholders' build, so Cargo would skip them
RUN touch src/main.rs src/lib.rs \
    && cargo leptos build --release --cargo-locked

FROM debian:trixie-slim
# hadolint ignore=DL3008
RUN apt-get update \
    && apt-get install -y --no-install-recommends ca-certificates \
    && rm -rf /var/lib/apt/lists/* \
    && useradd --uid 1000 --create-home app
WORKDIR /app
COPY --from=build /src/target/release/storefront /usr/local/bin/storefront
COPY --from=build /src/target/site ./site
ENV LEPTOS_SITE_ROOT=site
USER 1000:1000
EXPOSE 8080
CMD ["storefront"]

.git
.env*
*.log
/target
/end2end
Dockerfile
.dockerignore

shutting down
server stopped