DEV Community: rsc

Hosting your static website in a linux virtual machine

rsc — Wed, 30 Nov 2022 10:16:56 +0000

To host a website on a linux virtual machine is fairly simple. The website hosted will be available on the internet publicly as long as our Linux virtual machine is running.
In this tutorial, we'll be hosting a HTML template from tooplate.com, feel free to use your custom made HTML documents.

Prerequisites

Vagrant: This tutorial assumes a working knowledge of vagrant and how to automate creating virtual machines using Vagrantfile

Step 1. Create a virtual machine

Creating an ubuntu virtual machine

We'll be using spox/ubuntu-arm box image to setup our ubuntu virtual machine.

Navigate to your project directory and create the Vagrantfile with the following command.

vagrant init spox/ubuntu-arm

or copy and paste the Vagrantfile below.

Now, the Vagrantfile is created and can be edited through vim editor.

vim Vagrantfile

# -*- mode: ruby -*-
# vi: set ft=ruby :

# All Vagrant configuration is done below. The "2" in Vagrant.configure
# configures the configuration version (we support older styles for
# backwards compatibility). Please don't change it unless you know what
# you're doing.
Vagrant.configure("2") do |config|
  # The most common configuration options are documented and commented below.
  # For a complete reference, please see the online documentation at
  # https://docs.vagrantup.com.

  # Every Vagrant development environment requires a box. You can search for
  # boxes at https://vagrantcloud.com/search.
  config.vm.box = "spox/ubuntu-arm"

  # Disable automatic box update checking. If you disable this, then
  # boxes will only be checked for updates when the user runs
  # `vagrant box outdated`. This is not recommended.
  # config.vm.box_check_update = false

  # Create a forwarded port mapping which allows access to a specific port
  # within the machine from a port on the host machine. In the example below,
  # accessing "localhost:8080" will access port 80 on the guest machine.
  # NOTE: This will enable public access to the opened port
  # config.vm.network "forwarded_port", guest: 80, host: 8080

  # Create a forwarded port mapping which allows access to a specific port
  # within the machine from a port on the host machine and only allow access
  # via 127.0.0.1 to disable public access
  # config.vm.network "forwarded_port", guest: 80, host: 8080, host_ip: "127.0.0.1"

  # Create a private network, which allows host-only access to the machine
  # using a specific IP.
  config.vm.network "private_network", ip: "192.168.33.10"

  # Create a public network, which generally matched to bridged network.
  # Bridged networks make the machine appear as another physical device on
  # your network.
  config.vm.network "public_network"

  # Share an additional folder to the guest VM. The first argument is
  # the path on the host to the actual folder. The second argument is
  # the path on the guest to mount the folder. And the optional third
  # argument is a set of non-required options.
  # config.vm.synced_folder "../data", "/vagrant_data"

  # Provider-specific configuration so you can fine-tune various
  # backing providers for Vagrant. These expose provider-specific options.
  # Example for VirtualBox:
  #
  config.vm.provider "virtualbox" do |vb|
  #   # Display the VirtualBox GUI when booting the machine
  #   vb.gui = true
  #
  #   # Customize the amount of memory on the VM:
     vb.memory = "1024"
  end
  #
  # View the documentation for the provider you are using for more
  # information on available options.

  # Enable provisioning with a shell script. Additional provisioners such as
  # Ansible, Chef, Docker, Puppet and Salt are also available. Please see the
  # documentation for more information about their specific syntax and use.
  # config.vm.provision "shell", inline: <<-SHELL
  #   apt-get update
  #   apt-get install -y apache2
  # SHELL
end

Creating a centos virtual machine

We'll be using geerlingguy/centos7 box image to setup our cento7 virtual machine.

PS: For M1 users, I recommend you use jacobw/fedora35-arm64 instead of the above mentioned box image.

Navigate to your project directory and create the Vagrantfile with the following command.

vagrant init geerlingguy/centos7

Now, the Vagrantfile is created and can be edited through vim editor.

vim Vagrantfile

or copy and paste the Vagrantfile below.

# -*- mode: ruby -*-
# vi: set ft=ruby :

# All Vagrant configuration is done below. The "2" in Vagrant.configure
# configures the configuration version (we support older styles for
# backwards compatibility). Please don't change it unless you know what
# you're doing.
Vagrant.configure("2") do |config|
  # The most common configuration options are documented and commented below.
  # For a complete reference, please see the online documentation at
  # https://docs.vagrantup.com.

  # Every Vagrant development environment requires a box. You can search for
  # boxes at https://vagrantcloud.com/search.
  config.vm.box = "jacobw/fedora35-arm64"

  # Disable automatic box update checking. If you disable this, then
  # boxes will only be checked for updates when the user runs
  # `vagrant box outdated`. This is not recommended.
  # config.vm.box_check_update = false

  # Create a forwarded port mapping which allows access to a specific port
  # within the machine from a port on the host machine. In the example below,
  # accessing "localhost:8080" will access port 80 on the guest machine.
  # NOTE: This will enable public access to the opened port
  # config.vm.network "forwarded_port", guest: 80, host: 8080

  # Create a forwarded port mapping which allows access to a specific port
  # within the machine from a port on the host machine and only allow access
  # via 127.0.0.1 to disable public access
  # config.vm.network "forwarded_port", guest: 80, host: 8080, host_ip: "127.0.0.1"

  # Create a private network, which allows host-only access to the machine
  # using a specific IP.
  config.vm.network "private_network", ip: "192.168.33.10"

  # Create a public network, which generally matched to bridged network.
  # Bridged networks make the machine appear as another physical device on
  # your network.
  config.vm.network "public_network"

  # Share an additional folder to the guest VM. The first argument is
  # the path on the host to the actual folder. The second argument is
  # the path on the guest to mount the folder. And the optional third
  # argument is a set of non-required options.
  # config.vm.synced_folder "../data", "/vagrant_data"

  # Provider-specific configuration so you can fine-tune various
  # backing providers for Vagrant. These expose provider-specific options.
  # Example for VirtualBox:
  #
  config.vm.provider "virtualbox" do |vb|
  #   # Display the VirtualBox GUI when booting the machine
  #   vb.gui = true
  #
  #   # Customize the amount of memory on the VM:
     vb.memory = "1024"
  end
  #
  # View the documentation for the provider you are using for more
  # information on available options.

  # Enable provisioning with a shell script. Additional provisioners such as
  # Ansible, Chef, Docker, Puppet and Salt are also available. Please see the
  # documentation for more information about their specific syntax and use.
  # config.vm.provision "shell", inline: <<-SHELL
  #   apt-get update
  #   apt-get install -y apache2
  # SHELL
end

Required components to host the website in our `Vagrantfile`

IP Address to access the website: config.vm.network "private_network", ip: "192.168.33.10"
Optional assign a dynamic IP Address to the virtual machine: config.vm.network "public_network"
Hosting our website might need an extra amount of RAM, other than the default memory provided.

config.vm.provider "virtualbox" do |vb|
  #   # Display the VirtualBox GUI when booting the machine
  #   vb.gui = true
  #
  #   # Customize the amount of memory on the VM:
     vb.memory = "1024"
end

With the above configuration, we're ready to start the virtual machine.

Start the VM:

vagrant up

Log into the VM:

vagrant ssh

To provide the highest level of privilege, we need to login as the root user.

sudo -i

Step 2. Installing required packages, inside our VM.

Hosting our packages would require a couple of packages installed in our VM.

Run the command below, to install of them at once.

For ubuntu machine;

sudo apt install apache2 wget unzip -y

For centos machine;

yum install httpd wget unzip -y

P.S. httpd in centos is equivalent apache2 o ubuntu machine.

httpd: Apache web-server that hosts our website in the virtual machine.
wget: An http package to download our template from tooplate.com
unzip: This package is required because our template will be in .zip format, and needs to be extracted.

With the installation complete, the apache2 web-server has been automatically started by ubuntu, systemctl status apach2 to confirm. For centos machines, we can start our service by running the following command systemctl start httpd.

we could also enable the service, so that it comes up at boot time systemctl enable httpd

Access the default IP Address assigned to the VM:

ifconfig

result:

Access the IP Address in the browser, and the following default web page, would show up.

Download and extract the html directory into virtual machine.

Server data of our VM is located in the /var/www/html directory, this is where html files can be saved and served on the browser.

Step 1. Navigate to `/tmp` directory and download the zip file.

wget https://www.free-css.com/assets/files/free-css-templates/download/page285/cial.zip

Step 2. Extract the directory and copy it's content into `/var/www/html`.

Extract the document;

unzip cial.zip && cd html

Copy the content into /var/www/html

sudo cp -r * /var/www/html

Restart apache2/httpd and reload the browser

systemctl restart httpd

Reload the browser tab with your VM IP Address.

Introduction to Linux concepts, processes and operations

rsc — Tue, 06 Sep 2022 09:54:32 +0000

Outline

By the end of this tutorial, you should be able to;

Understand Linux startup operations and boot processes.
Identify the differences between partitions and filesystems on a Linux system.

Linux startup operations and boot processes.

The linux boot process is a series of operations involved when initialising the system, it includes all series of steps involved from the power on of the machine, to when the system user interface becomes fully operational.

The diagram below shows the operations involved in a Linux os boot process.

BIOS

The computer BIOS(Basic Input/Output system) checks and initializes all the computer hardware and ensure all of the hardwares are fully operational. This operational of hardware testing is called POST(power on self test).
The BIOS software is stored on a ROM chip, located on the motherboard.

Bootloader

The boot loader has two distinct stages:

For systems using the BIOS/MBR method, the boot loader resides at the first sector of the hard-disk, which is known as the master boot record - MBR.

For the first stage, the boot loader takes over the boot process, and search for a bootable partition such as GRUB.
The boot loader loads the Linux kernel into memory(RAM), and turn over execution process to the kernel.

For systems using the Extensible Firmware Interface(EFI)/Unified Extensible Firmware Interface (UEFI) method:

For the first stage, the boot loader read its boot manager data, to determine which application is to be launched and from where.
The firmware launches the application e.g GRUB as defined in the boot manager data

User login prompt

The init starts a number of text-mode login prompts. These enables the user type in their username and password, to eventually get a command shell.

The linux kernel

The boot loader loads both the kernel and an initial RAM-based file system (initramfs) into the memory so it can be used by the kernel.

Initial RAM disk

initramfs filesystem image contains programs and binary files that perform all actions needed to mount the proper root filesystem and device drivers for mass storage controllers with a facility called udev(user device).
After successful mount of the filesystem, the mount program instructs the operating system of the availability of the filesystem, and assigns a particular mount point to it, in the overall hierarchy of the system.
If this communication/operation is successful, the initramfs program is cleared from the RAM, and the init program (sbin/init) in the root filesystem is executed.
The init programs handles the final mounting and pivoting of the real root file system, needed by the Operating system.

sbin/init - parent process

Once the kernel has set up all its hardware and mounted the root file system, the kernel runs /sbin/init, which is the initial process needed to start other processes and get the system running.
Besides starting the system, init is responsible for shutting down the system cleanly.

The boot process is important in that, it allows the Linux user to intervene at any step and customise/configure the behaviour of the system to suit a specific need.

Startup alternatives

The two main startup alternatives developed were;

Upstart
Systemd

Systems with systemd start up faster than those with the earlier init methods, because systemd replaces a series of sequential steps with aggressive parallel processing technique, which allows multiple processes to be initiated simultenously.

With this approach, /sbin/init now points to /lib/systemd/systemd i.e systemd takes over the init process.

One systemd command is systemctl, which is used for basic service operations in the command line.
The following are a brief description of it's various uses;

Starting, stopping, restarting a service on a currently running system

$ sudo systemctl start|stop|restart mongodb

Enabling or disabling a system service from starting up at system boot

sudo systemctl enable|disable mongodb

Boot logs

The boot logs contains all the processes loaded and initialised during the boot process, the boot log information is contained in a file called dmesg located in the /var/log directory. The /var/log directory contains all the log files present on a system.

To show the content of the dmesg file, run the following command in the terminal;

dmesg | less

cat /var/log/dmesg

Linux Filesystems

Think of a refrigerator that has multiple shelves and can be used to store various items in an organised manner. The same concept applies to the filesystem, where different computer related data is stored in a human-readable format.

Different types of filesystems in Linux

Conventional disk filesystems e.g ext3, ext4, ntfs etc.
Flash storage filesystems e.g ubifs, yaffs, etc.
Special purpose filesystems e.g procfs, sysfs, debugfs, etc.

Partition and Filesystems

A Partition is a section of the hard-disk, used for specific operations.

A Filesystem is a method used for storing/finding files in the hard-disk, usually specific to a partition.

One can think of a partition as a container in which filesystem resides, although filesystem can span across multiple partition and linked together using symbolic link.

The Linux system stores important files according to a standard layout called the Filesystem Hierarchy Standard (FHS).
Unit OS, uses '/' character to separate paths (unlike windows, which uses '\'), and does not have drive letters e.g E: or C: used in windows OS.
Mounted drives and removable media devices are mounted as directory on the Linux filesystem.
USB drives, CDs and DVDs will show up as mounted on the /run/media/<your username>/disklabel directory or/media` for older Linux distributions.

All Linux filesystem names are case-sensitive, so /boot, /Boot, and /BOOT represent three different directories (or folders).

To get a feel of how the home directory Filesystem Hierarchy looks like, run the command below;

$ tree -aCd -L 2 /

Build a dockerized FastAPI application with poetry and gunicorn.

rsc — Thu, 01 Sep 2022 07:19:42 +0000

Prerequisites

Python3
docker
docker-compose

Setup FastAPI application

Why use Poetry for dependency and virtual environment management instead of pip and it's equilvalent python setups

Many developers loved the experience provided by Yarn and Npm in the NodeJS ecosystem. Poetry gives a similar experience to developers in the Python world.

This tutorial compares the approach used by npm for dependency management with poetry to show some of it's greatest strength and why you should use it.

Similar to package.json file in the NodeJS world, poetry uses a file named pyproject.toml file to specify the configurations for your project, and generates a lockfile automatically to describe the entire dependency tree.

A pyproject.toml file looks like this;

Setting up poetry on your machine

With python installed in your system, you can easily run

pip install poetry

For python3

pip3 install poetry

Successful installation can be confirmed with

poetry --version

App dependencies and virtual environment

With poetry installed, we can start a python application by simply running the following command

poetry init

and follow the command line prompt.
This command is similar to npm init -y in the NodeJS ecosystem.

a pyproject.toml file should be created where you can add your dependencies (the libraries that you will use during the project).

Activate the virtual environment with the following command

poetry shell

The last step is to add the dependencies for starting up a FastAPI application.

Adding a core dependency with poetry is simply done with poetry add [package name, while adding a dev dependency requires a --dev flag.

To begin working on our application, we need fastapi and unicorn as dependencies.

poetry add fastapi uvicorn[standard] gunicorn

Starting the application server with uvicorn

Firstly we need to create a new python file called main.py, this file will contain our route and also the app object, which is responsible for instantiating the FastAPI application.

Finally, we can start the application with the command shown below;

uvicorn main:app --reload

Now your application is running on http://127.0.0.1:8000 and the good news is: FastAPI is integrated with Swagger, the documentation is automatically generated and you can check it via http://127.0.0.1:8000/docs

Dockerize the FastAPI application

The first step for creating a docker container is to specify what, how and on which OS we need the application to run, and all these configurations reside in a file named as Dockerfile.

FROM python:3.10 as python-base
RUN mkdir python_tutorial
WORKDIR  /python_tutorial
COPY /pyproject.toml /python_tutorial
RUN pip3 install poetry
RUN poetry config virtualenvs.create false
RUN poetry install 
COPY . .
CMD ["gunicorn", "-w", "4", "-k", "uvicorn.workers.UvicornWorker", "main:app", "--bind", "0.0.0.0:8000"]

Let’s follow the file, line by line:

Line 1: Represents the base image (in our case its python), I have specified version 3.10 and you may change it accordingly(eg 3.9, 3.7, ..etc)

Line 2: Lets us create a folder named python_tutorial in our container

Line 3: Sets the created directory as our working directly.(So, all the commands below will be executed w.r.t python_tutorial as our root directory)

Line 4: Copy the file with the requirements to the application directory. Copy only the file needed to install the app dependencies only, and not the rest of the files in the app directly. As this file doesn’t change often, Docker will detect it and use the cache for this step, enabling the cache for the next step too.

Line 5: We install poetry so it can be used for dependency management in our app container

Line 6: We disable virtual environment creation inside the container, as it is only needed on the local machine

Line 7: We install all required libraries within container.

Line 8 : Copy all the files. As this has all the code which is what changes most frequently the Docker cache won’t be used for this or any following steps easily. So, it’s important to put this near the end of the Dockerfile, to optimize the container image build times.

line 9: Exposes our application to use gunicorn for starting the app. setting the worker to 4, and also bind the app port to 8000

Whoffff!!! Fans self!

I know that's a lot of facts, so let's take a break.😅

The current structure of our directory looks like this;

To elegantly manage our application docker image, we decide to use docker-compose. With docker-compose, we can configure and start multiple Docker containers connected to our application on the same host with a single command, and Hey! it looks cool🫣

Now, lets configure docker-compose.yml

version: "3"
services:
  api:
    build: .
    image: python_tutorial
    ports:
      - "8000:8000"
    volumes:
      - .:/python_tutorial:ro

Let's take a look at what's going on in the file;

Line 1: specifies version of docker-compose.

Line 3: We set a service named api.

Line 4 → 5: Specifies the path to Docker file and the tag name respectively.

Line 6: Specifies port mappings :

Line 7: sets the bind mount, to allow further changes to the application(development - not necessary in production)

Line 8: specifies the env file, if present

and finally run the following command;

docker-compose up

And if you are having a good day, you will get the following results on your terminal.

Screenshot 2022-08-31 at 00.09.30.png

Build a product review sentiment analysis with NestJS

rsc — Thu, 01 Sep 2022 07:16:24 +0000

Introduction

In this article, we'll demonstrate how to create a NestJS-based sentiment analysis application that uses natural language processing (NLP) to evaluate text data from user reviews and identify the user's sentiment(reaction).

Why do companies need sentiment analysis?

Offering clients what they genuinely want rather than what companies believe they need is what product managers need in order to build a strong product roadmap.

Sentiment analysis is the automated process that allows product managers to understand users' reviews of their products in an automated fashion.

The benefits of automated sentiment analysis are given below;

Recognize the pros and cons that customers have with your product.
Save hundreds of hours of tedious data processing and instead gain 24/7 access to the most recent product analytics automatically.
Compare the testimonials for your products to those of your rivals'.

Sentiment analysis is done through natural language processing. which is a technology that processes a user's comments on a product in order to derive meaningful and actionable data from them.

Prerequisite

Git for version control, and source code management.
NodeJS to run our application.

Setting up the application

To get started with setting up a Nest.js application, clone the starter repository i provided on my github account.

git clone https://github.com/r-scheele/nestjs-sentiment

Install all of the project's dependencies by changing directories into the newly formed folder.

cd nestjs-sentiment/ && npm install ```



Starting the application with;

npm run start:dev```

Now that our application has been successfully set up, let's use NLP to implement the sentiment analysis functionality.

First, we'll set up Natural, a Node.js package that covers the majority of the NLP algorithms we'll be utilizing for our project. Let's try the following command on our terminal:

Controllers

Controllers manage incoming requests and provide the client with response, so it makes sense to start our implementation from here.

// app.controller.ts

import { Body, Controller, Get } from '@nestjs/common';
import { AppService } from './app.service';
import { CreateReviewDto } from './create-review.dto';

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get('analyze')
  getAnalysis(@Body() analysis: CreateReviewDto) {
    return this.appService.getAnalysis(analysis);
  }
}

NestJS provides a @Body() decorator that gives us easy access to the request body, by introducing the concept of a Data Transfer Object (DTO), which is used to define the format of the data sent on the request, and the response. A DTO could be a class or a typescript interface.

// create-review.dto.ts

import { IsNotEmpty, IsString } from "class-validator";

export class CreateReviewDto {

    @IsString()
    readonly name: string;

    @IsString()
    @IsNotEmpty()
    readonly review: string;
}

Class-validator allows the use of decorators to validate the structure and type of the properties on the request object.

Nestjs service

The job of a service is to separate the business logic from controllers, making it cleaner and more comfortable to test. With the service, we can analyse user reviews, process it and return the sentient analysis.

// app.service.ts


// @ts-ignore

import { Injectable } from '@nestjs/common';
import { CreateReviewDto } from './create-review.dto';
import aposToLexForm from 'apos-to-lex-form';
import { WordTokenizer } from 'natural';
import SpellCorrector from 'spelling-corrector';
import { removeStopwords } from 'stopword';
import natural from 'natural';

const spellCorrector = new SpellCorrector();
spellCorrector.loadDictionary();

@Injectable()
export class AppService {
  analyzeReview(analysis: CreateReviewDto) {
    // format review
    const formattedReview: string = aposToLexForm(analysis.review)
      .toLowerCase()
      .replace(/[^a-zA-Z\s]+/g, '');

    // Tokenization
    const tokenizer = new WordTokenizer();
    const tokens = tokenizer.tokenize(formattedReview);

    // Correcting spelling errors
    const fixedSpelling = tokens.map((word) => spellCorrector.correct(word));

    // Removing stop words
    const stopWordsRemoved = removeStopwords(fixedSpelling);

    // Stemming
    const { SentimentAnalyzer, PorterStemmer } = natural;
    const analyzer = new SentimentAnalyzer('English', PorterStemmer, 'afinn');

    // Sentiment analysis
    const sentiment = analyzer.getSentiment(stopWordsRemoved);


    return sentiment;
  }
}

The analyzeReview() method has a couple of notable sections to be aware of;

User review processing

Since the raw data we receive from our user is frequently noisy and probably contains numerous errors, it must be transformed into a format that our NLP system can comprehend and use.
We must translate contractions (such as I'm, you're, etc.) to their standard vocabulary in order to keep uniform structure in our text data (i.e., I am, you are, etc.). We use the previously installed package apos-to-lex-form to accomplish this.
The text data is cleaned up( all non-alphabetical characters and symbols are removed), and converted to lowercase to ensure the sentiment algorithm treats good and GOOD as the same words.

Tokenization

This is the procedure for dividing a text into its various insightful parts. A sentence can be thought of as a token of a paragraph, and a word as a token of a sentence.

Correcting spelling mistakes

Typographical errors are likely because the product reviews will be manually authored by our consumers. Let's utilize the spelling-corrector package to fix typos before sending our data to our sentiment analysis algorithm. This way, if a user types lov accidentally, our algorithm will receive the correct spelling, love.

Removing stop words

The most frequent words in a language are typically stop words, which are eliminated before processing. Stop words contain phrases like but, a, or, and what. Eliminating these words will allow us to concentrate on the crucial keywords because they have no impact on a user's emotion.

Stemming

This is a word normalization procedure used in natural language processing (NLP) to return derived or inflected words to their base or root form. For instance, it is assumed that a stemmer algorithm will break down the words "giving," "gave," and "giver" into their basic constituent "give."

Sentiment analysis

As soon as the text data reaches the appropriate condition, we may analyze customer reviews using Natural's SentimentAnalyzer.

The Natural library's sentiment analysis system is based on a lexicon that gives words polarities. For instance, the polarity of the word "good" is 3, while the polarity of the word "evil" is -3. The algorithm calculates the sentiment by adding up the polarity of each word in a passage of text and normalizing with sentence length.

To get a more accurate result, preparing the data and eliminating all the noise was an essential step.
If our algorithm returns a negative value, The statement/word is regarded negative; if it returns a positive value, it is considered positive; and if it returns zero, it is deemed neutral.

The SentimentAnalyzer constructor has three parameters:

The language of the text data
The stemmer
The vocabulary (currently supports AFINN, Senticon, and Pattern) - we're using afinn in this example, because it's the simplest, yet most popular lexicon used for sentiment analysis

The completed version of this project can be found in my github profile;
clone the repository with

git clone -b project-end https://github.com/r-scheele/nestjs-sentiment.git

DEV Community: rsc

Hosting your static website in a linux virtual machine

Prerequisites

Step 1. Create a virtual machine

Creating an ubuntu virtual machine

Creating a centos virtual machine

Required components to host the website in our Vagrantfile

Step 2. Installing required packages, inside our VM.

Download and extract the html directory into virtual machine.

Step 1. Navigate to /tmp directory and download the zip file.

Step 2. Extract the directory and copy it's content into /var/www/html.

Restart apache2/httpd and reload the browser

Introduction to Linux concepts, processes and operations

Outline

Linux startup operations and boot processes.

BIOS

Bootloader

User login prompt

The linux kernel

Initial RAM disk

sbin/init - parent process

Startup alternatives

Boot logs

Linux Filesystems

Different types of filesystems in Linux

Partition and Filesystems

Build a dockerized FastAPI application with poetry and gunicorn.

Prerequisites

Setup FastAPI application

Why use Poetry for dependency and virtual environment management instead of pip and it's equilvalent python setups

Setting up poetry on your machine

App dependencies and virtual environment

Starting the application server with uvicorn

Dockerize the FastAPI application

Build a product review sentiment analysis with NestJS

Introduction

Prerequisite

Setting up the application

Controllers

Nestjs service

User review processing

Tokenization

Correcting spelling mistakes

Removing stop words

Stemming

Sentiment analysis

Required components to host the website in our `Vagrantfile`

Step 1. Navigate to `/tmp` directory and download the zip file.

Step 2. Extract the directory and copy it's content into `/var/www/html`.