Node App

nodeapp

In this article, I’ll show you how to deploy a app and associate it with a domain. Node.js Let’s get right to it! 1. Buying everything we need: Server (VPS): I bought it on Digital Ocean because I have 200$ free on this service, and I can also , but you can also buy a VPS on sites such as: give you 200$ hostinger.com contabo.com Domain: I got a free one on namecheap.com, but you can also buy a domain on sites such as: hostinger.com godaddy.com domain.com 2. Setting up a VPS: Server settings: The server settings depend on the load your site will be under and the complexity of the project. Since I will be deploying a simple site, I chose the most minimal settings. For the authentication method, I chose a password. Once our server is up and running, we can start connecting to it. Copy the IPv4 or IPv6 address, then open a terminal and enter the following command: Ssh root@164.90.218.8(instead of 164.90.218.8 put your IPv4) After this, it will ask you to enter the password that you set when creating the VPS: When you successfully log in, you will see something similar to this: From there, we have two ways to transfer our project folder. If you have it in a zip file on your local computer, you can use these commands to transfer the zip file with your project to the server. #if you have authentication method thought password
scp your-archive.zip root@164.90.218.8:~/
#if you have authentication method thought ssh key
scp -i ~/.ssh your-archive.zip root@164.90.218.8:~/ However, I suggest that you use GitHub. Log in to and use “git clone” to put your project in the global directory. For example, I will use my Node.js project called “ ”. GitHub qr_code_hunt_challenge Then, we need to install packages. Use the following commands on our VPS: #to update everything
sudo apt update
#after it shows us that we have packages that we can upgrade
sudo apt upgrade
#when you get Do you want to continue? [Y/n], you just write Y After this, go to the git repository using this link and choose the version of Node.js you need. In my case, I will use the latest LTS version. Press the copy button next to the commands and insert them in our VPS: If you encounter any errors: sudo apt-get update
sudo apt-get install -f
sudo apt-get clean
sudo apt-get install -y nodejs
sudo apt Then: #to install vim, zip, nginx
sudo apt install vim zip nginx Now, we need to make some changes in the firewall settings: sudo ufw allow 'OpenSSH'
sudo ufw allow 'Nginx HTTP'
sudo ufw enable 
#after all this commands you need to write
sudo ufw status
#and you will get something like this
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere                  
Nginx HTTP                 ALLOW       Anywhere                  
OpenSSH (v6)               ALLOW       Anywhere (v6)             
Nginx HTTP (v6)            ALLOW       Anywhere (v6) 3. Setting up a domain: First, we need to input our domain on the VPS hosting service. In my case, it is DigitalOcean. Go to the dashboard where you can check your VPS and start: When you insert the domain name and click “Add Domain,” you need to point to DigitalOcean in your nameservers. You can follow the guide from DigitalOcean using this . link In my case, I go to my dashboard in Namecheap and add everything as instructed in the guide: Second, we need to create a directory: sudo mkdir /var/www/your_domain.com
sudo chown -R $USER:$USER /var/www/your_domain.com/
sudo vim /etc/nginx/sites-available/your_domain.com The last command will open Vim, and here we need to insert this Nginx configuration: server {
    server_name your_domain.com www.your_domain.com;

    location / {
        proxy_pass http://localhost:3000;#here you need to change to your port
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
} Then, use these commands: rm -rf /etc/nginx/sites-available/default
rm -rf /etc/nginx/sites-enabled/default
sudo ln -s /etc/nginx/sites-available/your_domain.com /etc/nginx/sites-enabled/your_domain.com
#by next command you can check if everything okay
nginx -t
#now we need to reload our nginx
nginx -s reload Now, we need to move our Node.js project to another directory: cd /var/www/your_domain.com
mv ~/name_of_your_project_folder After using “ls,” you will see the folder or “.zip” file in your directory. If you just moved the “.zip” file, you need to unzip it using the command “unzip your_file.zip.” Now, we need to move all files from this directory: mv name_of_your_project_folder/* .
#and now we can delete this directory
rm -rf name_of_your_project_folder After that, use these commands: npm install
#and if you need some packages you can install now, in my case i will use:
npm init
npm install express
npm install ejs
npm install path
#and when you installed everything that you need, you can start your node.js
node server.js To make this site work without stopping: sudo npm install pm2@latest -g

pm2 startup systemd

pm2 start /var/www/your_domain.com/server.js

pm2 save

pm2 status
#after last command you should see If everything is okay, start using these commands: sudo systemctl start pm2-root

sudo systemctl reboot 4. Setting up HTTPS: To use HTTPS on our app, use these commands: sudo ufw allow 'Nginx Full'

sudo apt install certbot python3-certbot-nginx

sudo certbot --nginx -d your_domain.com -d www.your_domain.com

sudo systemctl status certbot.timer

sudo certbot renew --dry-run

sudo ufw delete allow 'Nginx HTTP'

#and if you upload some file on your app
sudo vim /etc/nginx/nginx.conf
#and here you need to insert in http {}
client_max_body_size 1000M; #here you can input any amout of megabytes

#and after all this
 nginx -t && nginx -s reload Now, our Node.js app is deployed and reachable through our domain, and everything is working. Finishing Up I hope you understood the instructions correctly. If you have any thoughts on this article, I will be waiting for your comments. If I really helped you, I kindly ask you to subscribe to my and provide feedback on this article. LinkedIn Also published here.

Deploying a Node.js App with an Associated Domain

Hello, everyone! Today, we'll be diving into the fascinating world of software development, specifically dealing with a serverless Node.js application, Microsoft Azure, and . These tools may sound intimidating, especially if you're new to software development, but I assure you, with some guidance, they are quite manageable. So, let's buckle up and get ready to learn. Redis Content Overview Introduction to Redis, Node.js, and Azure Setting up Node.js with Azure Installing Redis Connecting Node.js with Redis Testing the setup Introduction to Redis, Node.js, and Azure is an open-source, in-memory data structure store used as a database, cache, and message broker. It's a NoSQL key-value store that's excellent for handling data with high velocity or volume. Redis is a runtime environment for executing JavaScript code server-side. It's used for building scalable and efficient network applications. Node.js is Microsoft's cloud computing platform and service, where we'll be deploying our Node.js application. Specifically, we'll use , a serverless computing service that allows you to run your code without provisioning or managing servers. Azure Azure Web App Setting up Node.js with Azure For setting up all the required resources, I briefly explained in my previous article . How to Deploy a Serverless Node.js Application on Azure Installing Redis We need to install the Redis package on the Node.js project: npm install redis Then, we need to add some code to file: app.js import redis from 'redis';
import { createServer } from 'http';


// Create an redis conn.
const client = redis.createClient();
client.on('error', err => console.log('Redis Client Error', err));
await client.connect();

// For test.
await client.set('testKey', 'Hackernoon!');
const value = await client.get('testKey');

const server = createServer((req, res) => {
    res.statusCode = 200;
    res.setHeader('Content-Type', 'text/plain');
    res.end(`Hello, ${value}\n`);
});

server.listen(8080, '0.0.0.0', () => {
    console.log('Server running at http://0.0.0.0:8080/');
}); In package.json we need to add type: module: {
  "name": "hackernoon",
  "version": "1.0.0",
  "type": "module",
  "description": "",
  "main": "app.js",
  "scripts": {
    "start": "node app.js"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "redis": "^4.6.7"
  }
} Deploy it to the cloud and click “Start streaming logs“ (Img 1). Don’t forget to open the URL in the browser, it will turn on our web app after deployment. On the logs stream you will see: Redis Client Error Error: connect ECONNREFUSED ::1:6379 Now, we are ready to create a Redis app inside Azure and connect it. Connecting Node.js with Redis Search for Redis. On the Services, you will see “Azure Cache for Redis“ (Img 2). Click on “Create Redis cache“. You should choose the resource group that is using your Web App (Img 4). Create a resource and wait some time. Usually, it takes several minutes to complete. Then go to the resource “Overview” page and copy and paste it to the code": “Hostname” import redis from "redis";
import { createServer } from "http";

// Create an redis conn.
const client = redis.createClient({
  url: "redis://hackernoon.redis.cache.windows.net",
  password: "<Your PRIMARY password from Azure Redis Resource>",
});
client.on("error", (err) => console.log("Redis Client Error", err));
await client.connect();

// For test.
await client.set("testKey", "Hackernoon!");
const value = await client.get("testKey");

const server = createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader("Content-Type", "text/plain");
  res.end(`Hello, ${value}\n`);
});

server.listen(8080, "0.0.0.0", () => {
  console.log("Server running at http://0.0.0.0:8080/");
}); Password value you can find in “Access keys“ (Img 5). Also, go to Advanced settings, which is below “Access keys“ and put “No“ to Allow access only via SSL“. It will enable the Redis cache to work via the 6379 port. Testing the setup Finally, test your setup locally by running your Nodejs with the command. Your function should be able to access your Azure Redis instance. For deployment, push your project to Azure, and it should connect to the Azure Redis Cache. yarn start That's it! You've successfully created a Redis instance and connected it to a serverless Node.js application on Azure. Remember, Don’t make db, redis, and other resources to be public, and remember to use SSL. Try to create a closed virtual network and use it. Close everything if possible inside your private network. This guide is only for testing and learning. Practice is key when it comes to software development. Don't hesitate to tinker around with different settings and functionalities of Redis, Node.js, and Azure. The more you experiment, the better you understand. Happy coding!

How to Create and Connecting Redis to a Serverless Node.js App on Azure

Pheww!! You have worked hard and put all the effort into creating a dream Node.Js app for your project. After numerous hours of coding and debugging, you have finally come up with an end-product. Now the time has to launch your product in the market where anyone can see and use it. Yuppie!! Excited, Aint’ you? In this guide, I will explain the step-by-step process of deploying your first Node.Js application to the server using . web application development services So, let’s start now! Getting Started Well, using cloud-based technologies, you can deploy an app in different ways. If you , they may sure many services like Microsoft Azure, Google Cloud, or AWS to host your web app. Also, you and your team can use PaaS services like Heroku for quick and easy deployment. hire experienced NodeJs developers Moreover, deploying your Node.Js application to a bare Linux server on Cloud is difficult to find the right configuration and stack of technologies that stand up to your expectations. There are many Virtual Private Server – VPS you may come across from different reliable platforms. But, here, we are going to use Hostinger as it’s cost-effective and easy to configure with different add-ons. Here, I am using Ubuntu’s latest version – 20.04. So, follow the required steps to deploy your Node.Js app to a bare server. Here, we will use MySQL (As per your requirements of the app) DBMS Setup: For re-visiting HTTP Requests to our internal Node.Js Server, we’ll use . Setup a Reverse Proxy: Nginx Install Node & NPM. Install PM2 Node.Js Process Manager. From version control push/clone your code. Configure reverse proxy and run a local server. Follow the above steps to access your server’s IP or domain name on PORT 80 through your Node.Js app. Also, as a default port, 80 is considered for serving HTTP. Now, you are required to have an SSH to your server while using Hostinger. You will be able to see the server’s IP address on the right-hand side. You can keep SSH as root. ssh root@ 42.35 .40 .01 From Hostinger Cpanel, you can change the password of SSH. Install MySQL Database Its installation process is the same as other Debian (Ubuntu) packages throughout the apt. sudo apt install mysql-server sudo apt update When you run the configuration script, you have to make sure that you have accepted all the required permission from the server. Now configure the MySQL Deamon server. It will give tight security in a production-ready environment. sudo mysql_secure_installation After giving a command to the server, you can change some of the security options of MySQL. However, you have to configure the Validate Password Plugin in the first window. This way, you can check your MySQL password’s strength. For the second window, you have to set MySQL root user password. Once you are done with the window, you will have to press Y and Enter for accepting the defaults for all the subsequent questions. Now, no anonymous users can get through it. Moreover, it will also disallow remote root logins, erase the test database, and integrate these new rules. MySQL will adapt to the changes immediately. Don’t forget to check whether the MySQL server is running or not with the given command. systemctl status mysql If you see an Active or running status, this means your server has been successfully started without any issue. Now, connect the server with the MySQL client. mysql -u root Whoaa! Now, we have successfully configured the Database Server without any errors. mysql quit Nginx Reverse Proxy Here, we use Nginx reverse proxy to receive multiple requests from clients and serve it to different servers. We will use the Nodejs server here. As per my experience, Nginx is an amazing and reliable HTTP Server. It’s commonly used to serve static HTML Files and reverse proxy. It provides internal access to a server or those resources that are behind a firewall. Here, in our case, we will run the NodeJs app on port 3000 behind a firewall. Only through localhost, we can access it. Now, bind Nginx reverse proxy to port 80 – available for the public. Afterward, it can serve the localhost Nodejs server. Now is the time to install Nginx. sudo apt install nginx sudo apt update Now, apache2 is installed with Hostinger. It is fully configured to server HTTP on PORT 80. Hence, we have to disable apache2 from our server. sudo apt-get remove apache2* After using the command, all the apache2 packages and sub-packages will not be available. Now configure your Nginx server with a simple Test webpage. But before proceeding further, we have to install a firewall to secure our server. So, let’s install ufw (uncomplicated firewall). sudo apt install ufw To access your server in the future, you have to ensure that all the SSH connections pass through the firewall only. ufw allow ssh You have to write a given code to check which network application is available and has access through the firewall. >  Available applications:
   Nginx Full
   Nginx HTTP
   Nginx HTTPS
   OpenSSH ufw app list Opens both port 80 (normal, unencrypted web traffic) and port 443 (TLS/SSL encrypted traffic) Nginx Full: Opens only port 80 Nginx HTTP: Opens only port 443 Nginx HTTPS: Since we need HTTP through ufw, let’s allow Nginx. Allow the Nginx HTTPS or the Nginx Full. > Status: active
To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
Nginx HTTP                 ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
Nginx HTTP (v6)            ALLOW       Anywhere (v6) sudo ufw allow 'Nginx HTTP' If you can see allow in the action box of OpenSSH and Nginx HTTP, you are on the right path. As we can assume that, it also supports IPV6 Protocol. With a bellow written code, check the Nginx status. sudo systemctl status nginx Keep the Nginx status active. If it has not started automatically, then do it manually. sudo systemctl start nginx After completing this, we have to set up Nginx Server Block. From our given servers or multiple independent domains, you can serve subdomains. /etc/nginx/ Nginx Configuration address: : /var/www/ Nginx Main Server Root address Now, let’s create the main IP address or domain serving page root. sudo mkdir -p / var /www/servername.com/html Make sure the permission of web root should be correct with the given code. sudo chmod -R 755 / var /www/servername.com Here, -R (recursive) will define all servername.com sub-directories having the same permission as the parent directory. Then, write a given code. This code will assign the ownership of the directory having the existing user named $USER environment variable: sudo chown -R $USER:$USER / var /www/example.com/html Now, let’s make a simple index.html webpage for testing purposes. Then integrate the proxy of the Nginx server to our localhost running the NodeJs app. nano / var /www/servername.com/html/index.html Write the below-given HTML code inside. </html> <html> < head > < title > Welcome to servername.com! </ title > </ head > < body > < h1 > Success! The servername.com server block is working successfully! </ h1 > < b > Meow Meow! </ b > </ body > Now close the Nano text editor after saving. Moreover, we should add configuration at /etc/nginx/sites-available for Nginx to serve this content. sudo nano /etc/nginx/sites-available/servername.com You should keep the config file the same as your domain name to be easy for you to maintain. For a simple Nginx configuration, here is the code. index index.html index.htm index.nginx-debian.html; location / { } 
} server { listen 80 ; listen [::]: 80 ; root / var /www/servername.com/html; #Here, you can put your domain name for ex: www.servername.com server_name 42.35 .40 .01 ; try_files $uri $uri/ = 404 ; is only available for storing your configuration. If you have to make it active, create a link to the config to the sites-enabled directory to see the effect on the server. /etc/nginx/sites-available sudo ln -s /etc/nginx/sites-available/servername.com /etc/nginx/sites-enabled/ If you want to check errors in the new add config, run the below code. nginx -t Now, restart the Nginx for the new config for the modification. sudo systemctl restart nginx Now, try to browse the address of the server’s IP or domain name. You will be able to view the test page of the sample webpage served back to you. So, the Nginx server is running successfully behind the ufw firewall. Install Node Here, we will use , which you can download from . Generally, you can install Node from the apt package manager, but it will not let you install the latest version. NVM GitHub sudo apt install wget wget -qO-https: //raw.githubusercontent.com/nvm-sh/nvm/v0.34.0/install.sh | bash It will consider the script and execute it with bash to install NVM. install.sh To apply environment changes, you need to run the .profile or .bashrc from your home folder. And this completely depends upon your requirements and configuration. source ~/.profile source ~/.bashrc Now run command. It will run like a charm. nvm nvm -v 0.34 Now install Node and using NVM with the following code. NPM nvm install 11.0 Then Node and NPM commands will be available across the command line. node -v 11.0 Install PM2 and Cloning Repo is a NodeJs process manager. It tracks your running Node process to make a debug easier. Also, it shows the log files of running apps. PM2 Let’s install it. npm install pm2 -g It’s very easy to install, like the PM2 process. Now, there is a requirement of the Node.Js app’s code on the server. So, we will use Git Version Control to push and then clone the repository. git push origin master git add . git commit -m "Initial Commit" git remote add origin "https://github.com/username/your_repo" Now clone the repository with the given code. cd repos mkdir repos git clone https: //github.com/username/your_repo Suppose the framework is based on a simple Node.Js or Express server with app.js, then you need to use PM2 to start the process. cd /repos/your_repo Use PM2 now. pm2 start server app.js Here, we will use the app.js instance with PM2. We named it “server” so that we can easily identify our application. Once you are done with this process, you will get a table showing the running/stopped apps and CPU usage. Configure Reverse Proxy The Nginx configuration is already added with a simple index.html page. Now bind it to a localhost address, representing the address of the existing running NodeJs app. This is where an Nginx takes its place for a reverse proxy. Now open the config and do essential changes to work as a reverse proxy. servername.com { location /  

{ 
                proxy_set_header X-Real-IP $remote_addr; 
                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; 
                proxy_set_header Host $host; } 
} server listen 80 ; server_name 42.35 .40 .01 ; proxy_set_header X-NginX- Proxy true ; proxy_pass http: //localhost:3000/; proxy_redirect http: //localhost:3000/ https://$server_name/; Once you implement the above code, all your questions from Nginx will be redirected to . And that’s the place where you will find the NodeJs server running. http://localhost:3000 Now change the host and port of your existing NodeJs app. The provided custom headers will be sent with the proxied request to our NodeJs servers - $remote_addr and $host. These represent the real IP address of those users who raised the requests initially. Finally, everything is covered, and the setup is complete. You can access your server IP address or domain name on the browser where the NodeJs server handles the request. Isn’t that pretty cool? Haah!! Anyway, it’s a very cool thing to use a reverse proxy and port 3000 (NodeJs server port). However, this secures your web server or application. Bang on! You have deployed a NodeJs application on the server. Furthermore, if you are planning to develop a feature-rich NodeJs application, you can always have an by your side. That would help you lead the world with your ideas and their executions. experienced NodeJs development company

A Tutorial to Deploy the Node.Js App to Nginx Server

Un tutorial para implementar la aplicación Node.Js en el servidor Nginx

As a broad generalization, the JavaScript community is the least sensitive to Containerization as a first principle. The community is far removed from the discussions around container runtimes, ingress, networking, and orchestration – mostly because themes such as server-side rendering, code caching, and performance improvements are more relevant and relatable to them. In addition, tools such as Netlify and Vercel have provided a modern developer experience that makes deployments frictionless. The sheer convenience that these deployment tools provide has made the ecosystem desire the same kind of experience for all infrastructure. Getting JavaScript developers, as a community, to talk about containers and Kubernetes as a mainstream topic is a challenge. The ease of use they get from other tools plus the complexity of Kubernetes-based deployments makes it an order of magnitude harder to get the JS community to work with modern cloud infrastructure. This leads to a widening gap within the community between development and deployment. We are therefore left with the following questions – what is the best path for the JavaScript community to adopt modern application deployment methods? What is a means to deploy JavaScript apps to Kubernetes, minus the friction? Turns out that the cloud native community has some answers. The Cloud Foundry project , along with a Cloud Native Buildpacks implementation called , can provide a path for JavaScript application developers to deploy conveniently to Kubernetes. Both of these are open source and belong to the Cloud Foundry Foundation. cf-for-k8s Paketo Buildpacks By using the time-tested cf push interface, JavaScript developers don't have to make a choice between deploying conveniently and deploying to modern infrastructure. The Cloud Foundry developer experience is focused on simplifying deployments not just for JavaScript but for all other languages as well. Containers are built from source by internal stages in the deployment process thanks to Buildpacks which detect the language, runtime dependencies, and frameworks needed for each language and then supplies them during the build process. For JavaScript specifically, a set of Buildpacks are used to cover base, start, and install parts for both Node and Yarn based applications. Ultimately, what does this enable? This approach provides solutions to many problems that arise due to containerization workflows in the JavaScript ecosystem. Let us look at some of the common limitations and problems and see how Cloud Foundry provides a solution to these. Let's start with a fundamental problem - Writing a Dockerfile. In order to create a container for an application written in Node.JS, we need a . This will specify the commands needed to download dependencies, install the application, and finally start it. Dockerfile Dockerfiles are a combination of shell scripts and some context in which to execute them. They represent additional cognitive load for a JavaScript engineer and can be difficult to write and maintain as apps scale. Next, the convenient deployment methods promised by Netlify, Vercel, Cloudflare pages etc. are limited to static websites and not full-fledged applications. Developers who would like to deploy full stack applications are forced to look elsewhere. They either have to default to writing Dockerfiles or use platforms such as Heroku which are more accommodating of their needs. Which brings us to the next problem - . Netlify and Heroku, which are both popular among JavaScript devs do not expose the infrastructure that they run on. control over infrastructure Developers do not have any control over the nature of compute that will ultimately power their experience. There aren't options to accommodate multi- or hybrid- cloud architectures. Beyond all this, there is a long tail of best platform ops practices that cannot be implemented with JavaScript apps. The list includes (but is not limited to) multi-stage builds, HTTP proxies, npm install performance, healthchecks, CVE scanning, container logging, testing during image builds, and microservice docker-compose setups. As one example, let’s have a look at how Cloud Foundry solves these problems. First of all, using Paketo (or any other Buildpacks) eliminates the need for writing Dockerfiles. Consequently, the burden of maintaining them is also eliminated. Cloud Foundry can deploy single-page apps, complex applications, or headless API endpoints and builds them uniformly. With the , developers can deploy to a Kubernetes cluster of their choice, which is running on any infrastructure. cf-for-k8s project In addition, platform operators can make use of the Buildpacks to apply best practices during build time as opposed to pushing this as another task for developers to worry about. that explains how to deploy a full stack Node.JS application to Kubernetes using the . ( , if you're the sort that prefers to learn visually). Here's a link to a tutorial Cloud Foundry developer experience Watch a video instead Here are some of the highlights from the installation process: The command used to deploy the application is cf push foo-foo
Pushing app foo-foo to org test / space dev admin...Packaging files to upload...Uploading files... B / B [====================================================] % s
Waiting API to complete processing files...
Staging app and tracing logs... as 530 530 100.00 1 for The analysis phase within the cf push process identified the need for the following Buildpacks buildpacks participating   paketo-buildpacks/node-engine paketo-buildpacks/npm-install paketo-buildpacks/npm-start 3 of 4 0.1 .2 0.2 .1 0.0 .2 The Buildpacks selected the NPM build process and completed installing the app in a mere seconds. Selected NPM build process: Executing build process   Running Completed s 'npm install' 'npm install --unsafe-perm --cache /layers/paketo-buildpacks_npm-install/npm-cache' in 1.415 Finally, the build completes and the containers are cached as layers inside a container registry. These layers can be individually addressed and updated allowing operators to rebase the final image instead of rebuilding whole images during updates. After the build complete and the containers have been cached, the app is automatically started and a unique link(route) will be generated for you to see the app live. Paketo NPM Start Buildpack Assigning launch processes   web: node server.js   Adding layer Adding layer Adding layer Adding / app layer(s)   Adding layer Adding layer Adding label Adding label Adding label *** Images (sha256: d82765365bcceb52cc3b378e6f1d82e7869acd0543562039d855ad628918f6c):   registry.gitlab.com/ramanujank/test-container-registry/ be f71 e6a eb2e1076bcd   registry.gitlab.com/ramanujank/test-container-registry/ be f71 e6a eb2e1076bcd:b1 Adding cache layer Adding cache layer Adding cache layer Build successful
Waiting app foo-foo to start... 0.0 .2 'paketo-buildpacks/node-engine:node' 'paketo-buildpacks/npm-install:modules' 'paketo-buildpacks/npm-install:npm-cache' 1 1 'launcher' 'config' 'io.buildpacks.lifecycle.metadata' 'io.buildpacks.build.metadata' 'io.buildpacks.project.metadata' 8 278317 -6 -498e-9 -7 278317 -6 -498e-9 -7 .20210219 .123808 'paketo-buildpacks/node-engine:node' 'paketo-buildpacks/npm-install:modules' 'paketo-buildpacks/npm-install:npm-cache' for If you have questions when getting started with or, for that matter Cloud Foundry in general, go to the Cloud Foundry community at slack.cloudfoundry.org. You’ll find the community is more than happy to welcome and help you out. Also, for more information about the Cloud Foundry Foundation and what it does, visit . cf-for-k8s cloudfoundry.org

Step-By-Step Tutorial To Deploy A Node.js App To Kubernetes

In this tutorial, we are going to demonstrate how to deploy a using Section's Edge Compute Platform. distributed Node.js app at the Edge Before we get into the how-to's, you may be wondering why you would want to deploy your app at the Edge vs. a typical Cloud deployment. Well, the biggest reason is speed. Deploying your app closer to your end users reduces latency - . Aside from speed, there are additional security and scalability benefits that can be achieved by deploying your applications (or portions of your application) at the Edge. shown to be up to 7x faster than Cloud Let's do some coding! At the end of this tutorial, you will have: A website running as a subdomain at section.dev SSL certificates for your website Working knowledge of the CLI tool to deploy changes to your app sectionctl Prerequisites: You will need to sign up for a Section account Text editor Terminal app Install the CLI tool (instructions provided below). sectionctl Node.js version 10.14 or later Step 1: Set up the Section CLI tool After you have created your Section account, download the latest release of from . sectionctl Github On Linux, this looks like: wget https://github.com/section/sectionctl/releases/download/v1.1.0/sectionctl-v1.1.0-linux-amd64.tar.gz
tar zxvf sectionctl-v1.1.0-linux-amd64.tar.gz Next, you'll need to place the executable on your path and make sure that it can be executed. On Linux, this looks like: mv sectionctl /usr/ /bin/sectionctl
chmod +x /usr/ /bin/sectionctl local local Next, configure authentication by running: sectionctl login When prompted, enter your Section username and password, and security store them where can find them. sectionctl The Section CLI is now configured and ready to use. Step 2: Set up your Node.js application For this tutorial, we are going to set up a simple NuxtJS app to deploy on Section's Edge. Note: If you are on Windows, we recommend downloading and use Git Bash that comes with it, which supports the UNIX-specific commands in this tutorial. Git for Windows Open your terminal, into the directory where you wish to create your app, and clone the demo app: cd git https://github.com/section/nodejs-example clone Now, into your newly created directory called : cd nodejs-example nodejs-example cd Next, pull down the dependencies and build your app by running: npm install
npm run-script build Note: The Section platform expects that you have run both of these commands before you can deploy your app. Start your app's development server on port 8080 by running: npm run-script start You can check to see if it's working by opening in your browser. http://localhost:8080 Step 3: Deploy your Node.js app We will now take the example NuxtJS app that we set up in the previous step and deploy it across Section's Edge network. First, locate your account ID using the following command: sectionctl accounts This should return an output similar to this: | ACCOUNT ID | ACCOUNT NAME                      |
|------------|-----------------------------------|
| 1335       | g9ts24tx7gm8n12b2evf3.section.dev | Use the number value in the account ID column to list your applications: sectionctl apps list --account-id 1335 The output should look similar to this: | APP ID |    APP NAME                       |
|--------|-----------------------------------|
| 7171   | g9ts24tx7gm8n12b2evf3.section.dev | Note: The app name was automatically generated when you signed up. You will need this name for the final steps. Next, we will set up the SSL certificate for your domain. (This is a free service provided by Section.) Run the following command, substituting your account ID and app name: sectionctl certs renew --account-id 1335 --hostname g9ts24tx7gm8n12b2evf3.section.dev Wait a few minutes while Section uploads and deploys your Node.js app across the Edge network. You can now view your app running on Section by navigating to your provided app name. Congratulations! You have deployed your Node.js app on Section's Edge. Be sure to check out the in your Section Console to see how your app is performing across the globe. Traffic Monitor To learn more, check out Section Docs and/or contact a Section Edge Solutions Expert . Previously published at https://www.section.io/docs/getting-started/tutorials/launching-a-nodejs-app/

Step-By-Step Tutorial To Deploy A Distributed Node.js App At The Edge

In almost every application, you come to a point where you need to access the filesystem. This is an essential skill, that I personally use as a starting point when learning a new language or platform. With Node.js, you can rely on to work with the filesystem. Common tasks in this regard usually include: built-in modules Listing directories contents Reading, writing and updating files Manipulating filesystem paths Due to the nature of Node.js, coding these tasks might be a bit different from what can be seen in other languages/platforms, so it's always interesting to make sure you're starting with the right habits. asynchronous To get started with these tasks, I'll leave you in the hands of my friend , with short videos that run for less than 5 min each. Aaron Powell What you'll learn here How built-in and modules work fs path List the contents in directories Manipulate filesystem paths and get to know special Node.js paths Create files and directories, with proper error checking Read and update JSON files Additional learning resources Interactive in-depth tutorial on Node.js filesystem Source code of the demos Cross platform considerations when working with filesystems fs API reference path API reference Introducing and modules fs path Out of the box, Node.js comes with two built-in modules that you can use to work with the filesystem: and . Let's take a quick look at them to see how they work, and what they can be used for. fs path List directories contents Exploring directories to list the contents and file or filter particular files may sometimes be a bit challenging at the beginning, especially when using the asynchronous API. But instead of a plain explanation on how to do that, let's code it using a practical example. If you want to follow along, you'll find the code on . this repo Manipulate filesystem paths Sometimes manipulating the filesystem paths can be tricky, especially for cross-platform applications (looking at you, Windows 👀). Let's consider a practical use case like accessing the current file path of your program and see how to construct paths from it. Create files and directories (and check if it already exists) Creating new files is probably the main subject here. You'll have to make sure the folder containing them exist, and create it if it doesn't. The logic for checking whether files or folders exist may be a bit different from what you may be used to, so let's check that too. Read and update JSON files Reading a file might seem an easy job, but there's always the tricky question of . When writing text files, Node.js use encoding as the default, but you need to specify it when reading files otherwise you might be in for some surprises. Let's see how it goes for reading and updating JSON files, as it can be quite useful when manipulating app configurations. character encoding UTF-8 What's next We're done for this post, but that doesn't mean that you should stop there. You should consider this post as a practical crash course on using the filesystem with Node.js. And of course, there's a lot more to it than what we can cover under 5 minutes videos. In particular, I would like to bring to your attention potential issues if you're working with , as it's easy to trip over. different OS filesystems If you would like to deepen your knowledge around filesystem manipulation, you can take a look at this . Interactive in-depth tutorial on Node.js filesystem Thanks for reading! Also published at https://dev.to/sinedied/work-with-files-and-directories-in-a-node-js-app-4kh8

How to Work with Files and Directories in a Node.js App

So you wrote your Node.js application and need a way to launch it online? Here, I present a guide on setting things up that doesn't require prior knowledge of anything OS-related. First, let's go through the pros and cons of hosting your app on VPS. Pros: it's cheap you can host multiple projects on the same server (perfect for side projects) you have a lot of control over server administration Cons: it takes longer to set everything up it adds some time to maintain your server Ultimately, I recommend going this route if you like trying new things and want to learn some DevOps. For the sake of this guide, you will need your app, a VPS, and a domain name. Installing required software Assuming you're just started with a fresh VPS, you'll likely have a clean Ubuntu. We will need to install Node.js (to run your app), nginx (to set up a reverse proxy; more on that later), and certbot (to issue an SSL certificate). You will also likely need a DB (e.g. MySQL or PostgreSQL), but that's up to you. The easiest way to install these packages is to use . Look into documentation of the corresponding projects to get up-to-date instructions. apt Once you're done, you will also need to install , Node.js process manager: pm2 npm install pm2 And we're done! Now let's set it all up. Downloading and running your app Well, assuming you already have your code hosted on GitHub, this should be easy. should make its job. git clone One thing I should mention is that you will need to . That way, your server will be able to pull your private repository without password input. It's also much faster than type password manually each time you're pulling the newest code on your server. create an SSH key and link it to your GitHub Let's test an app by running it. npm install
node src/app.js pm2 As I mentioned, pm2 is a process management tool for your Node.js apps. It can do a lot of stuff like logging your app's output, recording hardware resource usage, restarting your app in case it goes down, but right now we're interested in starting an app in "daemon" mode. In short, "daemon" means your app won't stop when you press Ctrl+C or close a console window. Instead, it will run in the background until you explicitly tell it to stop. To start an app, run pm2 start src/app.js --name nodejs-app And that's it! Your app is running in the background, forever. Now you can control your app by its name: pm2 stop nodejs-app
pm2 start nodejs-app
pm2 restart nodejs-app nginx Now, nginx is a lot of things, really. Here, we will only scratch its surface by setting up a reverse proxy for our app. So what's a reverse proxy? Here's one way to put it: reverse proxy is a middleman between client and server that transforms an external route into an internal route. Say, if nginx catches request //app1.example http: .org it will route that request to an app deployed on port 3000, which is the port that we are using for our app. //app2.example http: .org can route to an app on port 3001, and so forth. Our config will include the domain we're expecting requests from, , and the port at which our app is deployed, . http://app.example.org 3000 First, create a configuration for your app: nano /etc/nginx/sites-enabled/app.example.org.conf Then, paste the following: server {
    server_name app.example.org;
    listen 80;
    
    location / {
        proxy_pass http://localhost:3000/;
        proxy_set_header Host ;
        proxy_cache_bypass ;
    }
} $host $http_upgrade Finally, test that our config is ok and restart nginx. nginx -t
systemctl restart nginx Now, if you actually want to test this thing, you will need a domain. The subdomain will also work fine, just replace all above with your full domain name. app.example.org Woohoo! You (and everyone else!) should now be able to access your app by typing its URL in a browser bar. certbot We're almost done! The final step is to set up an SSL certificate for your app so you can access it via . https We will do this via — a CLI tool for the awesome certificate service called Let's Encrypt. certbot Start by simply typing certbot You will see a list of domains. Likely you will have only one, the one we configured above, so it will be hard to choose the wrong one. Follow the guide, as certbot will create a certificate and update your nginx configuration. And that's it. Now, when you type your URL, it will work with https. Not only that, but it will also redirect non-secure http calls to https as well (if you chose that during configuration). Wrapping up I hope you didn't get lost in the process and successfully launched your app. If you found yourself spending an hour or two, don't worry: it will be much faster next time. Once you master it, you will be able to push projects to the Web in minutes!

How To Deploy your Node.js App on Digital Ocean VPS

How to launch a Node js app behind an Nginx proxy on Amazon EC2 instance in a step by step walkthrough. Two things before we start You need a few things before we start the launch: - make sure your Node app is ready and available to clone from a git repo Node js app in a git repo - if you don't have one yet, you can sign up AWS account here That's it, we are ready to roll! Launch an EC2 instance Sign in to your AWS management console Go to service EC2 Go to Launch instance Select the first one from the list: for the 64-bit (x86) - basically the first default option Amazon Linux 2 AMI Select instance type. Assuming you are running a simple app then go for the cheapest instance: . Click as we are blasting through the complexity here and will take all the default setting and only change the few we need later. On the next screen confirm again by clicking t3a.nano Review and launch Launch You will be asked to select an existing key pair or create a new key pair - it doesn't matter, we will be using a web based SSH client from AWS console to select any option. Click Launch Instances Click and go make yourself a cup of coffee while AWS is launching your new instance. It will take a few minutes. View Instances Set up security groups As your instance is being launched, you need to configure AWS security groups so that you and your website visitors will be able to access your app (and you will be able to connect to it via SSH). On EC2 Dashboard, find your new instance and scroll the view to the right to see what Security Group your instance is in. Remember the name of the security group In the left hand side menu find and go to Security Groups Select the security group and from 'Actions' select Edit inbound rules In inbound rules you want to add the following two rules: Type: SSH, Source: Anywhere Type: HTTP Source: Anywhere Click Save Go back to Instances Connect to your instance via SSH Ok, so you got your coffee and you can see your new instance status is 'running' and the status checks are green on the AWS EC2 Dashboard? Let's go then and connect to the instance via SSH: From the AWS EC2 Instances dashboard, select your instance, press Connect From connection options choose - this is the easiest and fastest option with no config required! EC2 Instance Connect (browser-based SHH connection) Install Node, git, yarn and PM2 to run your app Now the fun begins, we will blast through the installation of all the software you need. You will now be working in your SSH terminal 1. Update the system with the latest packages and basic environment sudo yum update 2. Install nvm in order to install Node in the next step: curl - - http //raw.githubusercontent. /nvm- /nvm/v0. /install. | bash o s: com sh 35.1 sh 3. Close and re-open your SSH console for the change to take effect 4. Install Node nvm install node 5. Install Git sudo yum git install 6. Install yarn. You are wondering ? Here is an article . Bottom line, yarn is quicker and more resilient. why not an npm why you should use yarn curl - - -L http //yarnpkg. /install. | bash o s: com sh 8. Re-open the terminal window for changes to take effect 9. Clone your Node app from your git repo git clone http //github. / / .git -- --
git clone http // @bitbucket.org/ / .git s: com <username> <repository-name> <folder-name> or s: <username> <username> <repository-name> 10. Check if it's there ls 11. Do you see a new folder with your app? Great, go to your app folder <your- -folder> cd app 12. Install your app packages yarn install 13. Install Node process manager to run your node app as a service. You need a so that it takes care of automatically restarting and reloading your app when something goes wrong. We will use PM2 - a very popular and production ready process manager. Node process manager pm2 yarn global add 14. Launch your node app with the PM2 process manager. The example below assumes your app starts via index.js. Replace index.js with another file, e.g. app.js or server.js depending on how you would normally start your app in Node. pm2 .js start index --name my-app 15. Make PM2 automatically restart your app if something goes wrong p startup m2 Retype the command the console asks you for in order to create the start up configuration. You need to re-type it as copy-paste does not really work in the console! It is a bit painful but make sure you get this one right as otherwise PM2 will not re-start. Now save the PM2 set up: pm2 save Set up Nginx to run your app behind the proxy 1. Install Nginx sudo yum nginx install You will get a warning command to install AWS curated Nginx package - great, that's what we need! sudo amazon-linux- nginx1. extras install 12 2. Edit Nginx config to redirect HTTP traffic from port :80 to the port your app is running on the local host. In the example below I assumed your app is running on port 3000. If your app is running on a different port make sure to reflect that in the line of code proxy_pass http://127.0.0.1:3000; in the configuration below: Open the editor: sudo nano nginx /etc/ /nginx.conf and edit the config file to contain the following server block (leave everything else as is): server {
   listen         80 default_server;
   listen         [::]: default_server;
   server_name    localhost;
   root           /usr/share/nginx/html;
   location / {
       proxy_pass http:// : ;
   }
} 80 127.0 .0 .1 3000 Just in case you are new to the - you can press Ctr + X to finish editing and you will be prompt whether to save the file. nano editor 3. Restart Nginx sudo nginx restart service 4. Set up Nginx to restart automatically if something goes wrong sudo chkconfig nginx on Up and running. You are done! Go to your AWS dashboard with EC2 instances and find the for your new instance. If you copy the url into the browser you should be able to see the output from your Node app. Public DNS (IPv4) Next steps 1. You still need to think how to set up a proper for your app domain I like to use AWS Route 53 and Cloudfront CDN to forward the traffic into the EC2 instance. That gives me resilience, free SSLs certificates and HTTPs redirects without having to worry about further Nginx configurations and management of certificate on the EC2 instance. 2. You need to configure your and learn more about the server and location blocks configurations. Nginx proxy headers 3. You probably want to set up a Git repo with your files so that you can edit them in a proper code editor and than just pull their latest versions into your EC2 instance Nginx configuration 4. Use a client like from your local machine. It will be a bit faster and smoother experience than the web client via AWS Console proper SSH PuTTY 5. Think about the caching strategy for your app

How To Create Node App with Nginx Setup on Amazon EC2

As an application developer, how often we sense the need of a service that would send e-mails to specified or subscribed email ids? Even if there is no real need, we still fantasize about it while developing a pet-project or an app for fun, don't we 😁? In this article, I am going to explain the simple steps to send emails from your node.js app. At the end of it, we will be able to schedule and send e-mails. Not only that, we will be creating a REST API to post required details to a node.js app for sending emails. TL;DR Here is the working app You can find the code from my GitHub Repo: Test REST app for Sending e-mails Setting the stage is a super cool module for Node.js application to allow email sending so easily. Install it using Nodemailer npm npm install nodemailer --save Import in your .js (app.js, email.js whatever) file: Nodemailer nodemailer = ( ); let require 'nodemailer' Next, follow these three simple steps to get things working: Setup a message option: This is to tell is sending message to ? Nodemailer who what whom mailOptions = { : , : , : , : }; let from '<FROM_EMAIL_ADDRESS>' to '<TO_EMAIL_ADDRESS>' subject 'Email from Node-App: A Test Message!' text 'Some content to send' 👉 Note: The `to` property above can have multiple email ids separated by commas(,). Create a `Nodemailer` *transporter* using either SMTP(this is default) or  [some other transport](https://nodemailer.com/transports/) mechanism transporter = nodemailer.createTransport({ : , : { : , : }
  }); let service 'gmail' auth user '<FROM_EMAIL_ADDRESS>' pass '<FROM_EMAIL_PASSWORD>' 👉 Note: In the above example, the `service` is mentioned as `gmail`. This is just an example. You can specify the name of the e-mail services you want to actually use. Use `sendMail()` method of your previously created transporter to deliver the message. transporter.sendMail(mailOptions, { (error) { .log(error);
        } { .log( + info.response);
        }
  }); ( ) function error, info if console else console 'Email sent: ' That's all, you are done. Now we have everything required to send e-mail from this node.js app. Hang on a Minute, We can schedule it! Yeah, right! The real power of this app comes with the fact that, you will be able to schedule the emails like, Send now Send everyday at 7p.m.(19:00 hrs), like a daily-digest Send every 30 minutes. Send on 29th Feb! ... many many more desired ways You guessed it right, we need something like a cron job and for that we will be using a node module called, . node-cron First install it. node install node-cron --save Import and schedule a task node-cron cron = ( );
 
 cron.schedule( , () => { .log( );
  }); let require 'node-cron' '* * * * *' console 'running a task every minute' 👉 Note: You can read about several cron schedule patterns . In the above example, we have scheduled a simple console log in every minute. here Here is the combined code where I am scheduling the e-mail to send every minute: cron = ( ); nodemailer = ( ); mailOptions = { : , : , : , : }; transporter = nodemailer.createTransport({ : , : { : , : }
    });
 
 cron.schedule( , () => { transporter.sendMail(mailOptions, { (error) { .log(error);
        } { .log( + info.response);
        }
    });
  }); let require 'node-cron' let require 'nodemailer' // e-mail message options let from '<FROM_EMAIL_ADDRESS>' to '<TO_EMAIL_ADDRESS>' subject 'Email from Node-App: A Test Message!' text 'Some content to send' // e-mail transport configuration let service 'gmail' auth user '<FROM_EMAIL_ADDRESS>' pass '<FROM_EMAIL_PASSWORD>' '* * * * *' // Send e-mail ( ) function error, info if console else console 'Email sent: ' TADAAA, Done! REST API to Schedule and Send e-mail Well, this is an optional part for you, if your are not interested in creating a REST API for the purpose of Scheduling and Sending e-mails. In case you mind, we can do it in a minute using . I have posted an article on . Please take a quick look. sails.js How to Deploy your Sails.js app on Heroku and live longer Create a route in file of your sails.js app routes.js : 'post /api/sendemail' 'EmailController.sendEmail' Create an with method. This method should have the code discussed above for scheduling and sending email. EmailController sendEmail Wow, that was quick, isn't it? 👉 Note: With sails.js, you can also use other cron libraries like as well. The details can be found . sails-hook-cron here Let me know if this was useful to you. Please feel free to comment on the alternate ways and methods you may be using for serving the same purpose, i.e, from a node.js ap .  After all, 😊😊😊 Scheduling and Sending e-mails Sharing is Caring....!!

How to Send and Schedule E-mails via a Node.js app

Deploying a Node application on an EC2 instance may seem like a daunting task but if you know how to configure your instance it is not that hard. We will be deploying a chat application written in Nodejs in the following steps Launch an EC2 instance and SSH into it. Install Node on EC2 instance. Copy code on your EC2 instance and install dependencies. Start server to run forever. So let’s get started. 1. Launch an EC2 instance and SSH into it You can refer to my article to launch an EC2 instance and SSH into it. Launching an Amazon EC2 instance When configuring the security group make sure you open the port on which your Node application will run. In my case, the port is 5000. 2. Install Node on EC2 Instance After doing SSH into your instance we will install Node on the instance. To install node run the following commands in your terminal or git bash curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.11/install.sh | bash . ~/.nvm/nvm.sh nvm install 8.10 The first command installs node version manager (nvm) that we are using to install node on Amazon Linux AMI. The second command activates nvm. The third command specifies which version of the node we would like to install. Here, I am installing the node version 8.10. You can check your node version by typing the following command in your terminal. node -v installing node 8.10 3. Copy code on your EC2 instance and install dependencies Most commonly there are two ways to do that 1. Using Github, BitBucket or Gitlab This is one of the most simple ways to get your code on your EC2 instance. But first, you have install git on your instance. Type the following command to install git on Amazon Linux AMI. sudo yum install -y git Now, you can run the command to clone the project. git clone Here, I am cloning a node chat application. git clone https://github.com/abkunal/Chat-App-using-Socket.io.git 2. Using Amazon S3 We can make a zip file of our node project (without including node_modules folder) and upload that zip file to our S3 bucket. We can then make our zip file publicly accessible, download it on our instance and unzip it. **For MacOS and Linux users**Right click on your node folder and select “compress” option. It will create a zip file compress a folder in MacOS **For Windows users**Right click on your node folder and select “Compressed (zipped) folder” option in “Send to”. Now let’s upload our zip file to an S3 bucket. Create a s3 bucket 1. Login to your AWS console and select S3. Click on the button, enter a unique name for your bucket and click on the button. Create bucket Next 2. Click button again and all the checkboxes in tab. Next uncheck Set Permissions modify s3 permissions settings 3. Click button and then click button. Next Create bucket upload zip file to s3 bucket 4. Select your newly created bucket and upload the project’s zip file to the bucket. make the zip file publicly accessible 5. Click on the zip file and then click on the button. Make Public 6. Copy the link given at the bottom and paste the following command in your terminal or git bash where you have ssh access to your instance. ` wget LINK Example - wget [https://s3.ap-south-1.amazonaws.com/abkun-chat-bucket/Chat-App-using-Socket.io.zip](https://s3.ap-south-1.amazonaws.com/abkun-chat-bucket/Chat-App-using-Socket.io.zip) 7. Run the following command to decompress the zip file. unzip filename.zip Example - unzip Chat-App-using-Socket.io.zip Install Dependencies You can now install your node dependencies by navigating to your folder and running the following command cd Chat-App-using-Socket.io   npm install install node dependencies 4. Start server to run forever Now, to keep our server running forever (even when we are not SSH logged in to the instance) we will use an npm package called pm2. 1. Install pm2 by running the following command npm install -g pm2 2. Set up pm2 to start the server automatically on server restart. pm2 start app.js   pm2 save   pm2 startup configure pm2 Note that after running the command we get a command starting with “sudo”. pm2 startup Copy that command from till the end of the next line and paste it in the terminal and press enter. sudo Now your node server is running and is set to start automatically whenever you restart the EC2 instance. chat application running on EC2 instance Now, you can use your instance’s IP address and the port on which your server is running to see your web application in action. If you have any questions, please comment below. Thanks for reading this article. If you liked it, please give a few claps so it reaches more people who would love it!

Stories, News & Mentions about NODEAPP

Categories

Trending Topics

Stories, News & Mentions about NODEAPP

Nodeapp’s Stories on HackerNoon

Categories

Trending Topics