How to deploy a Nest App?

NOTE: Spheron Compute offers the flexibility to create custom configurations for your instance.

NestJS is a powerful, scalable, and extensible framework for building efficient and maintainable server-side applications in Node.js. It combines the robustness of TypeScript with the flexibility of JavaScript, providing a structured architectural approach inspired by Angular that encourages modular development and code reusability.

In this guide, you’ll configure a Nest app and deploy it to Spheron Compute using Docker.

Prerequisites

To successfully follow this guide, you will need the following:

A DockerHub (opens in a new tab) account.
Nodejs (opens in a new tab) installed on your local machine.
A text editor. You can use Visual Studio Code (opens in a new tab) or your favorite text editor.

Step 1: Create a Nest App

Install NestJS CLI globally by running the following command in your terminal:
```
npm install -g @nestjs/cli
```
Create a new NestJS application by running the following command in your terminal:
```
nest new nest-app
```
Change into the project directory:
```
cd nest-app
```
Generate a controller using the NestJS CLI:
```
nest generate controller cats
```

Open cats.controller.ts and replace its content with the following code:

import { Controller, Get, Post, Body } from '@nestjs/common';
 
 @Controller('cats')
 export class CatsController {
   private cats: string[] = [];
 
   @Get()
   getCats(): string[] {
     return this.cats;
   }
 
   @Post()
   createCat(@Body() cat: string): string[] {
     this.cats.push(cat);
     return this.cats;
   }
 }

Generate a module using the NestJS CLI:
```
nest generate module cats
```

Open cats.module.ts generated after running the above command and replace its content with the following code:

import { Module } from "@nestjs/common";
import { CatsController } from "./cats.controller";
 
@Module({
  controllers: [CatsController],
})
export class CatsModule {}

Open app.module.ts and add CatsModule to the imports array:

import { Module } from "@nestjs/common";
import { CatsModule } from "./cats/cats.module";
 
@Module({
  imports: [CatsModule],
})
export class AppModule {}

Open main.ts and modify its content as follows:

import { NestFactory } from "@nestjs/core";
import { AppModule } from "./app.module";
 
async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}
bootstrap();

Save the changes and start the application by running the following command:
```
npm run start
```
Open your web browser and visit http://localhost:3000. To retrieve all cats, make a GET request to http://localhost:3000/cats. To create a new cat, make a POST request to http://localhost:3000/cats with a JSON payload containing the cat's name.

Check out the example here. (opens in a new tab)

Step 2: Create a Dockerfile

Here's what the dockerfile for this django app will look like:

# Use the official Node.js LTS (Long Term Support) image as the base image
FROM node:lts-alpine
 
# Set the working directory inside the container
WORKDIR /app
 
# Copy the package.json and package-lock.json files to the container
COPY package*.json ./
 
# Install the application dependencies
RUN npm install --production
 
# Copy the source code to the container
COPY . .
 
# Expose the port that the NestJS application will listen on
EXPOSE 3000
 
# Start the NestJS application
CMD [ "npm", "run", "start" ]

Step 3: Set default platform for docker build

Docker images built with Apple Silicon (or another ARM64 based architecture) can create issues when deploying the images to a Linux or Windows-based AMD64 environment. Before running the docker build command, run this command in your terminal:

export DOCKER_DEFAULT_PLATFORM=linux/amd64

Step 4: Build Docker image

To build the Docker image:

Save the above Dockerfile in the root directory of your Nest app.
Open a terminal and navigate to the root directory of your project where the Dockerfile is located.
Run the following command to build the Docker image:

docker build -t nest_server .

After the build process completes, you can run a container based on the image using the following command:

docker run -p 8000:8000 nest_server

Step 5: Push the app to DockerHub

To push an image, you first need to create a repository on Docker Hub.

Create a repo

To create a repository on Docker Hub:

Sign up (opens in a new tab) or Sign in to Docker Hub (opens in a new tab).
Select the Create Repository button.
For the repo name, use nest_server. Make sure the Visibility is Public.
Select the Create button.

Push the image

Login to the Docker Hub using the command docker login -u YOUR-USER-NAME.
Use the docker tag command to give the nest_server image a new name. Be sure to swap out YOUR-USER-NAME with your Docker ID.

docker tag nest_server YOUR-USER-NAME/nest_server

Now try your push command again. If you’re copying the value from Docker Hub, you can drop the tagname portion, as you didn’t add a tag to the image name. If you don’t specify a tag, Docker will use a tag called latest.

docker push YOUR-USER-NAME/nest_server

Here's what a Docker Image will look like on Docker Hub:

Docker-Image

Check out this docker image here. (opens in a new tab)

Step 6: Run on Spheron Compute

To run your app on Spheron:

Click "New Cluster" on the top right corner.
Choose "Compute" to use CPU-based instances for running containers.
Choose your desired Compute Type option under Compute Type.
Select Import from Docker Hub.
Enter the names for your cluster and docker image.
Then, Add the tag and Click "Next."
Select your preferred Region, if any. If you do not add a region, the container will be deployed in any region for Spot, or in the eu-east region for On Demand. Click here to know more.
Spheron will automatically select the recommended plan for the specific template. If you intend to move forward with the recommended plan, Create new Port Policy Mapping and just Click "Deploy" to initiate deployment.
Select the instance plan that suits your needs. You can use the "Create Custom Plan" toggle to create custom plans for your CPU based instance.
Configure Storage (SSD) plan for your instance. Use the "Add Persistent Storage" toggle to add persistent storage for your instance.
Create new Port Policy Mapping. Add the container port, and Select the exposed port you want to map it to. Click here to know more.
Add Environment Variable, if any.
Add Secret Environment Variable if the value is a secret key. It will not be saved in the database. Click here to know more.
You can add advanced configuration if required. Click here to know more.
You can add health checkup if required. Click here to know more.
Click "Deploy" to initiate deployment.

NOTE: Spheron supports only public docker images at the moment.

Verify Installation

The Nest App can be accessed only after the Compute Instance is provisioned. Thus, you need to wait for the installation to complete before you can start using the app. Your Apps can be verified for successful installation using the instructions below, while others may require different procedures.

Follow these instructions to verify the installation:

Attempt to access the app
An App has an estimated deployment time of about 1-2 minutes. If you can successfully access it, the installation has been completed successfully. You can connect using the connection URL of the instance, which will also be provided after the instance is provisioned.
Check instance logs and events
After successfully deploying your Nest App, it will produce logs and events, which you can check for any issues or errors.

Common Errors

Docker Fails When Building on Apple Silicon

🚫

ERROR: exec /usr/local/bin/docker-entrypoint.sh: exec format error

export DOCKER_DEFAULT_PLATFORM=linux/amd64

Deploy Express App Marketplace App Guide