Setup

1. Introduction

Setting up a robust development environment is the first step towards building scalable microservices. This chapter guides you through the installation of NodeJS, TypeScript, and the Fastify framework. By the end, you’ll have a fully functional setup ready for building enterprise-grade microservices.

2. Prerequisites

Before proceeding, ensure you have the following:

• Operating System: Windows, macOS, or Linux
• Terminal Access: Command Prompt, PowerShell, or a terminal emulator
• Code Editor: Visual Studio Code (recommended) or any other code editor of your choice

3. Installing NodeJS

NodeJS is a JavaScript runtime built on Chrome’s V8 JavaScript engine. It allows you to run JavaScript code on the server side and is essential for setting up our environment.

Step 1: Download NodeJS

1. Visit the official NodeJS website: https://nodejs.org
2. Download the latest LTS (Long-Term Support) version. The LTS version is recommended for production use because it provides stability and extended support.

Step 2: Install NodeJS

• Windows: Run the downloaded installer and follow the prompts. Ensure that the option to add NodeJS to your system PATH is selected.

• macOS: Run the installer package and follow the installation prompts.

• Linux: Use the following commands to install NodeJS via the terminal:

  # Update package index
  sudo apt update
  
  # Install NodeJS and npm
  sudo apt install -y nodejs npm

Step 3: Verify Installation

After installation, verify that NodeJS and npm (Node Package Manager) are installed correctly by running the following commands in your terminal:

node -v
npm -v

You should see version numbers for both commands, indicating that NodeJS and npm are installed.

4. Installing TypeScript

TypeScript is a superset of JavaScript that adds static typing, making it ideal for developing large-scale applications. It enhances code quality, readability, and maintainability.

Step 1: Install TypeScript Globally

Use npm to install TypeScript globally on your system:

npm install -g typescript

Step 2: Verify the Installation

Check the installed version of TypeScript by running:

tsc -v

You should see the installed version number, confirming that TypeScript is ready to use.

5. Setting Up a Project Structure

To ensure consistency and scalability, it’s essential to set up your project correctly from the start.

Step 1: Create a Project Directory

Create a new directory for your microservice project and navigate into it:

mkdir my-microservice
cd my-microservice

Step 2: Initialize the Project

Initialize a new NodeJS project by running:

npm init -y

This command generates a package.json file that manages your project dependencies and scripts.

Step 3: Set Up TypeScript Configuration

Create a TypeScript configuration file (tsconfig.json) by running:

tsc --init

This command generates a tsconfig.json file with default TypeScript settings, which you can adjust later according to your project needs.

6. Installing Fastify

Fastify is a highly efficient web framework for NodeJS, designed for speed and low overhead. It supports JSON schemas, hooks, and plugins, making it ideal for building microservices.

Step 1: Install Fastify

Install Fastify as a project dependency using npm:

npm install fastify

Step 2: Install Fastify Types (Optional but Recommended)

To take full advantage of TypeScript, install Fastify’s types package:

npm install @types/node

This package provides type definitions for NodeJS, ensuring strong typing and code intelligence in TypeScript.

7. Verifying the Setup

Let’s create a basic Fastify server to verify that our environment is set up correctly.

Step 1: Create the Entry File

Create a new file named server.ts and add the following code:

import Fastify from "fastify";

// Create a Fastify instance
const fastify = Fastify({ logger: true });

// Define a simple route
fastify.get("/", async (request, reply) => {
  return { message: "Hello, Fastify!" };
});

// Start the server
const start = async () => {
  try {
    await fastify.listen({ port: 3000 });
    console.log("Server running at http://localhost:3000");
  } catch (err) {
    fastify.log.error(err);
    process.exit(1);
  }
};

start();

Step 2: Compile and Run the Server

Compile the TypeScript file to JavaScript using the TypeScript compiler (tsc) and run the server using NodeJS:

# Compile TypeScript
tsc server.ts

# Run the compiled JavaScript
node server.js

Step 3: Test the Server

Open your browser and navigate to http://localhost:3000. You should see the message:

{ "message": "Hello, Fastify!" }

This confirms that NodeJS, TypeScript, and Fastify are installed and working correctly.

8. Conclusion

You have successfully installed NodeJS, TypeScript, and Fastify, and verified your setup with a basic server. This foundational setup will serve as the backbone for building robust, scalable microservices. In the next chapters, we will dive deeper into configuring Fastify, adding routes, and exploring advanced TypeScript features to build enterprise-grade microservices.