December 1, 2023

Launch a Rust Actix App

Build and Deploy a Rust Web API Using the Actix Framework. This Template comes configured with a Postgres database.


Rust developent and deployment on Noop is straightforward and productive.

This guide is based on the Postgres example published by the Actix Framework maintainers.

If you’re interested in starting a Actix app from scratch, install Workshop and select the Rust Actix Template. The create-Template process in Workshop will automate everything outlined in this guide.

If, on the other hand, you want to modify an existing project to use Noop, the guide here can be used as reference.

The full source code constructed for this guide, including the Noop configuration, see the Template repository.


Noop Dependencies

Make sure you have Workshop installed locally or a Github account connected to Noop Cloud. The remaining setup is identical in both.

Project Setup

OTo start a new Actix project, follow their official getting started guide, or use your own project.

The complete Template and project source code for the example created in this guide can be found on Github.

Template Configuration

After you have the Actix project set up, you need to add the Noop Template configuration to create a local or cloud Deployment.

Create a .noop directory in your project root.

mkdir .noop

Next create a blueprint.yaml file to define the application setup.

The content below is the necessary config for our app:

  - name: ActixApi
    type: service
    image: rust:latest
    port: 8080
        - directory: /app
        - copy: [Cargo.toml, Cargo.lock]
          destination: ./
        - copy: src
          destination: ./src
        - copy: sql
          destination: ./sql
        - run: cargo build --release
        - PgDatabase
      command: /app/target/release/actix-api
          $resources: PgDatabase.username
          $resources: PgDatabase.port
          $resources: PgDatabase.password
          $resources: PgDatabase.database
        PG__POOL__MAX_SIZE: "16"
        SERVER_ADDR: ""
  - target:
      component: ActixApi
  - name: PgDatabase
    type: postgresql

Automating Cloud Setup

For Cloud users, most of the Application setup is automated, including Environment creation, database provisioning, building and deploying, etc., using a Runbook. To create a Runbook, make a file called quickstart.yaml in the .noop/runbooks directory.

Here is the Runbook content:

name: Quickstart Setup
description: Demo full stack setup of a Actix app with internet endpoint
    - name: EnvironmentName
      description: What should we name your new environment?
      type: string
      required: true
      default: Quickstart Demo

    - name: Cluster
      type: Cluster
      description: Which cluster should the environment launch on?
      required: true

  timeout: 300

    - name: Environment
      action: EnvironmentCreate
          $inputs: EnvironmentName
        production: false

    - name: Build
      action: BuildExecute

    - name: Resources
      action: ResourceLaunch

    - name: Deploy
      action: DeploymentExecute

    - name: Endpoint
      action: InternetEndpointRandom
          - name: 'Demo Environment'
                - $steps:

Launch on Noop

Cloud users can use the Runbook to automate most of the setup described below.

Create an Application

Select “New Application” and assign an appropriate name for your new app.

Cloud Setup

In Cloud, once the Application is created you will be asked if you want to execute a Runbook. The name of the Runbook for this Template is “Quick Start”.

Choose the default cluster and run it. Behind the scenes this Runbook is:

  • Creating an Environment
  • Setting up placeholders for required environment variables
  • Launching the database
  • Building the source code
  • Deploying the build
  • And finally, creating a public-facing endpoint to serve the application from

Once complete, visit the Application page to get the generated endpoint. Your new Actix app is now running at that URL.

The Noop Template Blueprint contains all the details about the application. Including build process, required resources, application routing rules, runtime configuration, etc.

Workshop Setup

While workshop doesn’t have a Runbook, the setup is also automated.

In Workshop select your Application, which should have been automatically detected by Workshop, or select the appropriate project directory (must include a .noop directory).

Workshop will automatically create a default environment with all Resources launched.

Once done, you should see your application running on the associated endpoint.

Post-launch Setup

After the Environment is up and running in either Cloud or Workshop, this example requires a database schema to be in place before the application can function properly.

From the Console Environment page (the same in Workshop and Cloud), select the Postgres database resource. On the Postgres Resource page you will find a Resource Explorer where you can input a query.

Past the contents from the sql/schemas.sql file.

To verify the table was created run SELECT * FROM users; in the Resource Explorer. You should see an empty result set with the columns belonging to the just added users table.

Testing It Out

Once the app is deployed, it can be used by sending a POST request to the users endpoint. See curl example below (replace with the generated Noop Endpoint host):

curl -i -d '{"email": "", "first_name": "noop", "last_name": "dotdev", "username": "noop"}' -H 'Content-Type: application/json' https://<ENDPOINT>/users