?? Deploy Your Node.js Backend on Azure Using Terraform: A Simple, Scalable Solution for Startups

When launching a startup, time and resources are often limited. You need to focus on building your product rather than managing complex infrastructure. Fortunately, Azure provides a powerful platform, and Terraform enables you to automate the creation of your infrastructure efficiently. In this blog post, we’ll walk you through how to deploy a Node.js backend and a PostgreSQL database on Azure—all with a few simple Terraform commands.

Whether you’re building a new startup or refining an existing product, this solution gives you the flexibility to scale up as your customer base grows, without adding unnecessary complexity to your infrastructure.

This solution is heavily influenced by this document.

Why Choose This Approach?

If you're in the explore phase of your startup, looking to get your product into the hands of your first users, simplicity is key. You don't need a complex microservices setup or infrastructure management headaches. Instead, focus on getting your product working fast, with easy scalability and low operational overhead.

By leveraging Azure App Service and PostgreSQL, along with Terraform for automation, you can quickly set up a backend that’s ready to scale when your business is ready to grow. This approach allows you to:

- Minimize manual configuration.

- Easily scale the backend as needed.

- Focus on building features, not infrastructure.

- Stay cost-effective while still leveraging enterprise-grade cloud services.

Step 1: Preparing Your Terraform Backend

Before you dive into deploying your backend, it's important to set up Terraform’s state storage. Storing your Terraform state remotely is crucial for collaboration and managing your infrastructure in the long run.

Create the terraform.tfvars file under a state-storage folder: This file will define variables for the Azure Storage Account and the container used to store your Terraform state.

....
resource_group_name = "your-resource-group"
storage_account_name = "lucidappstorage"
container_name       = "tfstate"
location             = "East US"        

Initialize Terraform and apply your configuration to set up the backend:

terraform init
terraform apply        

This will create the Azure Storage Account and container to securely store your Terraform state. You’re now ready to automate the rest of your infrastructure.

Step 2: Deploying the Backend Infrastructure

Now that your Terraform backend is ready, it’s time to deploy the backend infrastructure for your Node.js app.

• Create the terraform.tfvars file in the root folder to define variables for your app service and PostgreSQL database.

environment = "production"
namespace   = "lucidapp"
region      = "West Europe"
github_auth = "xxxx"
repository = "johndoe/mybackendapp"        

• Define the Azure resources you’ll need, including App Service for hosting the backend and PostgreSQL for database storage.

locals {
  prefix = "${var.environment}-${var.namespace}"
}

# Get the resource group previously created in the state-storage
data "azurerm_resource_group" "demo" {
  name = "your-resource-group"
}

# Create App Service Plan
resource "azurerm_service_plan" "demo" {
  name                = "${local.prefix}-asp"
  location            = var.region
  resource_group_name = data.azurerm_resource_group.demo.name
  os_type             = "Linux"
  sku_name            = "F1"
}

# Create App Service for Node.js backend
resource "azurerm_linux_web_app" "demo" {
  name                          = "${local.prefix}-service"
  location                      = var.region
  resource_group_name           = data.azurerm_resource_group.demo.name
  service_plan_id               = azurerm_service_plan.demo.id
  public_network_access_enabled = true
  https_only                    = true

  site_config {
    always_on = false
    application_stack {
      node_version = "20-lts"
    }
  }

  # This will create the environment variable needed for our application
  app_settings = {
    "SCM_DO_BUILD_DURING_DEPLOYMENT" = "true"
    "DATABASE_URL"                   = "postgresql://${azurerm_postgresql_flexible_server.demo.administrator_login}:${azurerm_postgresql_flexible_server.demo.administrator_password}@${azurerm_postgresql_flexible_server.demo.fqdn}/lucidapp"
    "PORT"                           = "3010"
  }
}

# Create PostgreSQL Database
resource "azurerm_postgresql_flexible_server" "demo" {
  name                          = "${local.prefix}-psqlflexibleserver"
  location                      = var.region
  resource_group_name           = data.azurerm_resource_group.demo.name
  version                       = "16"
  public_network_access_enabled = true
  administrator_login           = "psqladmin"
  administrator_password        = "xxxpasswordxxx"
  zone                          = "1"

  storage_mb   = 32768
  storage_tier = "P4"

  sku_name = "B_Standard_B1ms"
}

# For this part we will make it available publicly for the demo to work,
# but we can make it more secure by allowing only specific ip address/addresses
# or the resource azurerm_postgresql_flexible_server will be under in a virtual network
# but for this demo this should be sufficient to make it work
resource "azurerm_postgresql_flexible_server_firewall_rule" "demo" {
  name             = "${local.prefix}-psqlflexibleserver-fw"
  server_id        = azurerm_postgresql_flexible_server.demo.id
  start_ip_address = "0.0.0.0"
  end_ip_address   = "255.255.255.255"
}        

• Run Terraform to deploy the backend infrastructure:

terraform apply        

Once applied, this will deploy:

- A Node.js backend running on Azure App Service, with easy scaling and zero infrastructure management.

- A PostgreSQL database to handle your app's data needs.

Step 3: Scaling with Ease and Automating Deployments

The beauty of this setup lies in its scalability and simplicity. Azure App Service allows you to scale your Node.js backend horizontally (add more instances) with minimal effort. As your startup gains traction and customer demand increases, you can easily scale up to meet the needs of your growing user base.

With this infrastructure in place, you can also automate the deployment process using Terraform and GitHub Actions. This ensures that new changes to your backend are deployed quickly and consistently, without manual intervention.

Conclusion: Getting Your Startup Up and Running Quickly

This simple monolithic architecture enables you to deploy a fully functional Node.js backend and a PostgreSQL database on Azure—all with the power of Terraform. By automating the infrastructure setup, you free up your time to focus on what truly matters: building and improving your product.

Ready to deploy your own app?

Check out the complete Terraform Code Repository and the Node.js Backend Repo to get started today!

This blog post focuses on the backend infrastructure, making it appealing to startups that need to quickly get their product to market with minimal operational overhead.

#Startup #TechStartups #DevOps #CloudComputing #SoftwareDevelopment #NodeJS #WebDevelopment #BackendDevelopment #TechForStartups #SaaS #ScalableInfrastructure #Automation #ContinuousDelivery #CI_CD #CloudNative #Microservices #Serverless