DEV Community: shiva kumar

How to remove Nginx server version and name.

shiva kumar — Tue, 22 Feb 2022 22:12:58 +0000

Hackers mostly exploit, when they know server name and its version. We can reduce the chances first by hiding the name and version of the Nginx. Secondly, by regularly updating the tools we use.
This quick post will guide you on renaming the Nginx server name and remove version from the headers
If you haven't install Nginx or you dont know how to install Nginx in a ubuntu machine you can follow this tutorial

You can check if the server is running by using below command

sudo service nginx status

Let's see when request the server, what we get in response header

ubuntu@ip-172-31-37-234:~$ curl -I localhost

HTTP/1.1 200 OK
Server: nginx/1.18.0 (Ubuntu)
Date: Tue, 22 Feb 2022 20:57:32 GMT
Content-Type: text/html
Content-Length: 612
Last-Modified: Tue, 22 Feb 2022 20:56:10 GMT
Connection: keep-alive
ETag: "62154dea-264"
Accept-Ranges: bytes

To rename the default server we need a directive called more_set_headers but this doesn't comes default with Nginx we need to install a dynamic module called headers-more-nginx-module

If you have installed nginx ubuntu package, you need download the same version of Nginx already installed. This need to be done to compile the dynamic module.
Lets download and unzip the nginx

wget http://nginx.org/download/nginx-1.18.0.tar.gz

tar -xvzf nginx-1.18.0.tar.gz

Since have already installed nginx we can view the list of modules installed. You can do that by using

nginx -V 

nginx version: nginx/1.18.0 (Ubuntu)
built with OpenSSL 1.1.1f  31 Mar 2020
TLS SNI support enabled
configure arguments: --with-cc-opt='-g -O2 -fdebug-prefix-map=/build/nginx-BUo7Uw/nginx-1.18.0=. -fstack-protector-strong -Wformat -Werror=format-security -fPIC -Wdate-time -D_FORTIFY_SOURCE=2' --with-ld-opt='-Wl,-Bsymbolic-functions -Wl,-z,relro -Wl,-z,now -fPIC' --prefix=/usr/share/nginx --conf-path=/etc/nginx/nginx.conf --http-log-path=/var/log/nginx/access.log --error-log-path=/var/log/nginx/error.log --lock-path=/var/lock/nginx.lock --pid-path=/run/nginx.pid --modules-path=/usr/lib/nginx/modules --http-client-body-temp-path=/var/lib/nginx/body --http-fastcgi-temp-path=/var/lib/nginx/fastcgi --http-proxy-temp-path=/var/lib/nginx/proxy --http-scgi-temp-path=/var/lib/nginx/scgi --http-uwsgi-temp-path=/var/lib/nginx/uwsgi --with-compat --with-debug --with-pcre-jit --with-http_ssl_module --with-http_stub_status_module --with-http_realip_module --with-http_auth_request_module --with-http_v2_module --with-http_dav_module --with-http_slice_module --with-threads --with-http_addition_module --with-http_gunzip_module --with-http_gzip_static_module --with-http_sub_module

Lets copy the output and pass them when recompiling the nginx-with-headers-more module

Let's download and install the nginx-with-headers-more module

git clone https://github.com/openresty/headers-more-nginx-module.git 

cd nginx-1.18.0/

./configure  --add-dynamic-module=/home/ubuntu/headers-more-nginx-module  <--with... paste the previously installed module from above nginx -V command>

make

Once its done we have module in /home/ubuntu/nginx-1.18.0/objs directory. We need to move this to existing installed nginx modules directory

sudo cp ngx_http_headers_more_filter_module.so /usr/lib/nginx/modules/

Now the headers-more-nginx-module is available to use. Go to the nginx.conf file include the installed module and add both directives to http block

user www-data;
worker_processes auto;
pid /run/nginx.pid;
include /etc/nginx/modules-enabled/*.conf;
load_module modules/ngx_http_headers_more_filter_module.so;

events {
        worker_connections 768;
}

http {
        sendfile on;
        tcp_nopush on;
        types_hash_max_size 2048;
        server_tokens off;
        more_set_headers 'Server: Gandalf';  #Gandalf will protect your server from balrog.
}

Restart the nginx server

sudo service nginx restart

Let check again the response header

curl -I localhost
HTTP/1.1 200 OK
Date: Tue, 22 Feb 2022 21:57:08 GMT
Content-Type: text/html
Content-Length: 612
Last-Modified: Tue, 22 Feb 2022 20:56:10 GMT
Connection: keep-alive
ETag: "62154dea-264"
Server: Gandalf
Accept-Ranges: bytes

If you want complete remove the server name, pass server name empty like this in nginx.conf file

more_set_headers 'Server: ';

Output

 curl -I localhost
HTTP/1.1 200 OK
Date: Tue, 22 Feb 2022 21:58:02 GMT
Content-Type: text/html
Content-Length: 612
Last-Modified: Tue, 22 Feb 2022 20:56:10 GMT
Connection: keep-alive
ETag: "62154dea-264"
Accept-Ranges: bytes

Congratulations! You have successfully renamed the server name and removed the version.
Hope this post was helpful. If you enjoyed this post, share it.

SSHing from Ubuntu to windows

shiva kumar — Wed, 19 Jan 2022 21:11:53 +0000

Recently I was trying to access windows server 2016 from ubuntu 20.04 without password. Best way to do that using shh but windows server 2016 doesn't come with ssh installed. Download the OpenSSH-Win64.zip

Extract the file in C:\Program Files\, after that open sshd_Config_default with notepad and uncomment the line port 22. Shh connect the remote machine in port 22.

Now open powershell and run the following commands

powershell.exe -ExecutionPolicy Bypass -File install-sshd.ps1

Allow inbound for ssh on port 22
New-NetFirewallRule -Name sshd -DisplayName 'OpenSSH Server (sshd)' -Enabled True -Direction Inbound -Protocol TCP -Action Allow -LocalPort 22

Start sshd, this will also create host key in C:\ProgramData\ssh

net start sshd

Check if the service is running

Get-Service -Name ssh-agent,sshd

From your powershell create a new file
New-Item -ItemType file "C:\ProgramData\ssh\administrators_authorized_keys"

Copy the public key from client ubuntu machine and append it to adminstrators_athorized_keys file. Creating a public key can be done using ssh-keygen in Ubuntu

Restart the service using the command in powershell

Restart-Service -Name sshd, ssh-agent -Force

ssh Administrator@windows-ip-address
Now from ubuntu machine you can successfully ssh to windows machine.

Hope this helps. Follow me for quick tips and solution for daily challenges

Reference:
OpenSSH Key management
Win32-OpenSSH

Creating Pipeline in Jenkins

shiva kumar — Tue, 04 Jan 2022 21:51:47 +0000

If you want to get started in DevOps, Jenkins is most important and handy software you should learn.In this article, I will run you through how to install Jenkins and create first Pipeline

Jenkins can be installed in numerous ways, I will be using docker to run the jenkins locally.

To run the below command you need docker.

docker run --name jenkin-master -d -v /Users/shiva/jenkins_home:/var/jenkins_home -p 8080:8080 jenkins/jenkins:jdk11

This command downloads the jenkins:jdk11 image and runs it, -v create a volume to maintain data persistence, runs the Jenkins in port 8080 with name jenkin-master

Go to http://localhost:8080 to access the Jenkins. You will see below screen

To access the path given in the Jenkins page, we need to log into the docker image with below command

docker exec -it jenkin-master /bin/bash

-it stands for interactive terminal

Once you are in, use the below command to get the password
cat /var/jenkins_home/secrets/initialAdminPassword

In Next screen, select Install suggested plugins, once its done you can create a new admin user.

click next and start using jenkins

You will land on this page.

On the left you will see the menu, click on New Item , then select Pipeline and give it a name firstJob

Pipeline is a series of step which helps in building the software. In other words, pipeline is used to implement and integrate continuous delivery.

There are two types of pipeline,
-> scripted &
-> declarative
We are going to write our first declarative pipeline.

After creating your firstJob scroll down to Pipeline and write the below code in the editor

Pipeline -> All the declarative scripted pipeline starts with a pipeline block
agent -> instructs Jenkins to run the stages on any agent or node
stages -> Stages contain one or more stage.
stage -> Stage reside inside the stages and it should have a steps block. Every stage will have a name like Test, Build, Deploy. Here we named our stage as Hello
steps -> Steps are written inside the stage and it contains list of commands or scripts that need to run. Here we just wanted to echo "Hello World."

Once you have saved your first declarative Pipeline, let's run it. Click on Build Now. After the build is done, you can click on build number 1 from build history then in the left menu click on Console Output to view the output of the build

As you can see, the "Hello World" is successfully printed in the output console.

Congratulations! You have created your first pipeline in Jenkins, We will use this as a base to build complete continuous delivery.

Hashify.app, Share Sensitive Data Securely !

shiva kumar — Fri, 25 Dec 2020 10:46:09 +0000

Recently, I was involved in an audit. We used to send important files zipped and password-protected, share the password of it over email or chatting software. I always felt uncomfortable while sharing credentials or secret messages over chatting software or email. Because it lives in the database of those chat/email companies forever, exposing you to potential security risks. That's where hashify comes to solve that itch. Our little app can help you. Signup to get notified of the launch https://hashify.app

Block, Lambda, and Proc in Ruby

shiva kumar — Mon, 30 Nov 2020 04:13:07 +0000

Block

Blocks are pieces of code between {} or do and end keywords. We can pass parameters in the block. Blocks are not object.

{ puts 'Hola, I'm a block'}

do 
  puts 'Hola, I'm a block'
end

Proc

Block can be converted to objects using Proc. Proc is assigned to a variable and its executed by using .call method.Proc can be defined using

Proc.new {}

proc {}

Proc accepts arguments but it doesn't throw an error when called with a lesser or more argument than expected

my_proc = Proc.new { |x|  "x = #{x}" }
 => #<Proc:0x00007f91ea9eada8@(irb):57>
my_proc.call(2)
=> "x = 2"

my_proc = Proc.new { |x,y,z| "x = #{x}, y = #{y}, z = #{z}" }
 => #<Proc:0x00007f91eaa00e78@(irb):59>
my_proc.call(2,3)
 => "x = 2, y = 3, z = "

my_proc.call([2,3])
 => "x = 2, y = 3, z = "

my_proc.call(2,3,5)
 => "x = 2, y = 3, z = 5"

Lambda

Lambda and Proc are similar. Lambda is a little anonymous function, which can be stored in a variable.Lambda will throw error if arguments passed is less or more than expected just like function

Lambda can be defined using the lambda keyword or -> {}

hello = lambda {"Hola"}

or

hello = -> {"Hola"}


my_lambda = lambda { |x| "x =  #{x}" }

my_lambda.call(2)
2


my_lambda = lambda { |x,y,z| "x = #{x}, y = #{y}, z = #{z}" }

my_lambda.call(2,3)
Traceback (most recent call last):
        7: from /Users/nbt040/.rvm/gems/ruby-2.6.3/bin/ruby_executable_hooks:24:in `<main>'
        6: from /Users/nbt040/.rvm/gems/ruby-2.6.3/bin/ruby_executable_hooks:24:in `eval'
        5: from /Users/nbt040/.rvm/rubies/ruby-2.6.3/bin/irb:23:in `<main>'
        4: from /Users/nbt040/.rvm/rubies/ruby-2.6.3/bin/irb:23:in `load'
        3: from /Users/nbt040/.rvm/rubies/ruby-2.6.3/lib/ruby/gems/2.6.0/gems/irb-1.0.0/exe/irb:11:in `<top (required)>'
        2: from (irb):67
        1: from (irb):66:in `block in irb_binding'
ArgumentError (wrong number of arguments (given 2, expected 3))

Lambda return works like functions. Proc will return from the current context

def lambda_method
 lambda { return "Returned from Lambda block" }.call
 return "return from method"
end

 lambda_method()
 => "return from method"

def proc_method
 Proc.new { return "Returned from the Proc block" }.call
 return "return from method"
end

proc_method()
 => "Returned from the Proc block"

Proc and Lambda behave differently in accepting the argument and how they return. Lambdas are proc but procs are not lambda. Hope this quick guide helped you in understanding Block, Proc and Lambda.

Quick difference in ruby's Each vs Map vs Collect vs Select

shiva kumar — Sat, 28 Nov 2020 04:54:34 +0000

Ruby iterators simply explained with an example

Each vs Map vs Collect vs Select

All of them iterators an array but the difference is on the return value

array = [1,2,3,4]

Below code prints 2,3,4,5 but returns original array

array.each do |a|
  puts a+1
end
2
3
4
5
=> [1, 2, 3, 4]

Map and Collect have the same functionality with a different name. Iterates through each element and return a new array of elements returned by the block

array.collect {|a| a + 1}
=> [2, 3, 4, 5]

Select iterates and return new array of elements for which given block is true

 array.select  { |num|  num.even?  } 
[2, 4]

Summary:

Each -> returns same array
Map & collect -> returns new array with code executed in block for each element
Select -> return new array for the which give block is true

In next post, we will look into more enumerable methods which are handy to know.

The Order doesn't matter anymore

shiva kumar — Wed, 18 Nov 2020 14:34:06 +0000

Have you ever been in a situation where you have to remember the order of the parameter while initializing an object? This a dependency, that can be easily overcome by using a hash. Enough talk, let's see the code

Before

class Employee

  def initialize(name, age, gender, department)
    @name = name
    @age =  age
    @gender = gender
    @department = department
  end

end

employee = Employee.new('Mat', 50, 'M', 'Dev')
=> #<Employee:0x00007fa700803d20 @name="Mat", @age=50, @gender="M", @department="Dev">


After

class Employee

  def initialize(args)
    @name = args[:name]
    @age =  args[:age]
    @gender = args[:gender]
    @department = args[:department]
  end

end

employee = Employee.new(age: 50, department: 'Dev',name: 'Mat', gender: 'M')
=> #<Employee:0x00007fa6fc8ab060 @name="Mat", @age=50, @gender="M", @department="Dev">

As you can see above the order doesn't matter anymore. You don't to remember parameter order to create an employee object. What if while initializing an object you have to set a default value. For this it's better to use ruby's in build method called fetch for hash

class Employee

  def initialize(args)
    @name = args.fetch(:name)
    @age =  args.fetch(:age)
    @gender = args.fetch(:gender)
    @department = args.fetch(:department, "dev")
  end

end

employee = Employee.new(name: 'Mat', age: 50, gender: 'M')

=> #<Employee:0x00007fa6fe8a1f18 @name="Mat", @age=50, @gender="M", @department="dev">

Hope this quick tip was helpful. Share your tips in comments. Let me know if you are interested in more such tips and best practices.

How To Exit Vim?

shiva kumar — Fri, 17 May 2019 10:50:28 +0000

If you are new to Vim or you have accidentally opened this editor where you type and nothing happens and you are stuck in this plain maze and don't know how to exit?

To exit you such press :q and hit enter. Nothing happened and you are in still in Vim then press escape and then type :q

Now that you know how to exit. Let's dig in more, there are two modes in Vim.

Insert mode : Press i for insert mode. Where you can just type like a normal text editor.
Command mode : Press ESC for command mode. Where you give commands to the editor to get things done. You can see below left-hand corner of the screen what you are typing.

x – to delete the unwanted character
u – to undo the last the command and U to undo the whole line
CTRL-R - to redo
A – to append text at the end
:wq – to save and exit
:q! – to trash all changes
dw – move the cursor to the beginning of the word to delete that word
2w – to move the cursor two words forward.
3e – to move the cursor to the end of the third word forward.
0 (zero) to move to the start of the line.
d2w – which deletes 2 words .. number can be changed for deleting the number of consecutive words like d3w
dd - to delete the line and 2dd to delete to line .number can be changed for deleting the number of consecutive words

The format for a change command is: operator [number] motion
operator – is what to do, such as d for delete
[number] – is an optional count to repeat the motion
motion – moves over the text to operate on, such as w (word),
$ (to the end of the line), etc.

p – puts the previously deleted text after the cursor(Type dd to delete the line and store it in a Vim register. and p to put the line)
r – to replace the letter e.g press re to replace the letter with e
ce – to change until the end of a word (place the cursor on the u in lubw it will delete ubw )
ce – deletes the word and places you in Insert mode
G – to move you to the bottom of the file.
gg – to move you to the start of the file.

To move the cursor to specific line number press the number and then G, for example, 3 and G will move the cursor to the third line

% – to find a matching ),], or }
:s/old/new/g – to substitute ‘new’ for ‘old’ where g is globally
/ – backward search n to find the next occurrence and N to search in the opposite direction
? – forward search
:! – to run the shell commands like :!dir, :!ls
:w – TEST (where TEST is the filename you chose.) . Save the file
v – starts visual mode for selecting the lines and you can perform an operation on that like d delete
:r – Filename will insert the content into the current file
R – to replace more than one character
y – operator to copy text using v visual mode and p to paste it
yw – (copy)yanks one word
o – opens a line below the cursor and start Insert mode.
O – opens a line above the cursor.
a – inserts text after the cursor.
A – inserts text after the end of the line.
e – command moves to the end of a word.
y – operator yanks (copies) text, p puts (pastes) it.
R – enters Replace mode until is pressed.
ctrl-w to jump from one window to another

type a command :e and press ctrl+D to list all the command name starts with :e and press tab to complete the command

To learn more on Vim, if you in Mac or Linux you can just type the command vimtutor. which has detailed documentation

Below are some fun way to learn Vim

Nginx as a Load balancer (Part-III)

shiva kumar — Thu, 02 May 2019 10:30:10 +0000

Nginx as a load balancer, this is 3rd part of the series(Part I and Part II). The first step in scaling your server. Let's keep it simple.

What is load balancer?

Loadbalancer is a method used for distributing traffic across the servers. Before we get into details of load balancing, there are two ways we can scale the server. First, Vertical scaling, in this we add more computing power i.e by increasing RAM and CORE to an existing server but this will be expensive after a certain point. Second, Horizontal scaling is to add more servers of the same or different configuration and install the required application to run our web app. Below image gives a gist about vertical vs horizontal scaling

Why do you need it?

To increase the application performance, availability and to decrease the latency when faced with heavy traffic. When our server cannot handle too many requests or the number of users visiting our website increases. Our application can get slow and users can get annoyed since the time taken to do any task increases. This is bad user experience. This is when we scale our servers.

Nginx as Load Balancer

Nginx is a software load balancer. It can be used as HTTP load balancer efficiently by distributing the request across multiple application servers which will increase the app availability (even if one server goes down), performance and scalability. There are hardware load balancers which are quite expensive & require separate resources for maintenance and debugging, which can be become quite a tedious task. Successful case studies of companies using nginx as a load balancer and some companies replaced their hardware load balancer with nginx.

First, we will need a dedicated server where we run only nginx whose job will be just to forward the request upstream. Let's add three more application servers. Instead of pointing the application to our single server we now point our domain or first landing request to nginx load balancer. Nginx will decide where the request should be forwarded based on the techniques mentioned below.

Image showing our architecture

Follow the below steps to get started -

First, let's create a config file called load_balancer.conf inside

    cd /etc/nginx/conf
    sudo touch load_balancer.conf

Open the load_balancer.conf and add the below configuration.

    http {
        upstream wayne_tech {
            server server1.com;
            server server2.com;
            server server3.com;
        }

        server {
            listen 80;

            location / {
                proxy_pass http://wayne_tech;
            }
        }
    }

Let's save this configuration file and include this file in our main configuration file and restart the server. Refer Part II post if you need to know how it's done.

server1.com, server2.com and server3.com, IP configuration need to be added in /etc/hosts. Let's do that.

    sudo vi /etc/hosts

    192.168.1.101   server1.com
    192.168.1.102   server2.com
    192.168.1.103   server3.com

Now that all the configurations are done. When any request comes to the web app it lands on the load balancer and it decides where to forward the request.

There are different load balancing techniques supported by nginx.

1) round-robin(default)

By default, Round-robin algorithm is used, in which each request is given to upstream server in sequence. i.e the first request will land on server1 and second request will land on server2 and so on.

    upstream wayne_tech {

        server server1.com;

        server server2.com;

        server server3.com;

    }

2) least-connected

In this technique, nginx will not overload the server which is already processing a lot of requests; instead, it directs the requests to a less busy server. Nginx will compare each active connection with servers and send the request to a least active connection. We just need to add a least_conn directive in our upstream configuration

    upstream wayne_tech {

        least_conn;

        server server1.com;

        server server2.com;

        server server3.com;

    }

3) ip-hash

If you need to map a client to a particular application server,i.e to keep client persistent or to maintain a state, ip-hash can be used. Requests are distributed based on the client's IP address which is used as a hashing key to serve the request to the server. This will make sure that the same client requests are directed to the same server unless that server is down.

   upstream wayne_tech {

        ip_hash;

        server server1.com;

        server server2.com;

        server server3.com;

    }

4) Weighted load balancing

In this method, we give weights to the servers. We can use this when our servers are not identical in configuration. For example, server1 has 16GB RAM and 8 CORE processor and whereas the other two servers have an 8GB and 4 CORE processor. Below configuration shows weight {6, 2, 2} which indicates that for every 10 requests, 60% percent of the request is given to server1 and 20% of the request is directed to server2 and remaining 20% to server3.

    upstream wayne_tech {

        server server1.com weight=6;

        server server2.com weight=2;

        server server3.com weight=2;

    }

Conclusion:

This is the last post on nginx series. Now that you know how to set up and install a server. And if your application receiving loads of traffic and use one of these techniques to distribute the load across the server. I encourage you to dig in the nginx documentation to unwrap its power and there is an enterprise edition of nginx plus which gives you more features. I have been using Nginx for almost a decade I never felt the need for enterprise edition even though we are serving millions of request per server per day. Reach out to me if you need any help. That's all folks.

Beginners guide to logrotate.

shiva kumar — Sun, 21 Apr 2019 12:19:01 +0000

Now that you have installed and setup Nginx in production for your web application. Your site is getting a good amount of traffic and all the logs are written in single file. This can be cumbersome to perform a certain task on file like searching and archiving the logs. Wouldn't be easy if can write daily logs on a separate file and compress the old logs and archive it separate place this will help us in optimizing the hard disk space.

Welcome to logrotate.

Logrotate is built-in ubuntu. With Logrotate we can do automatic rotation, compression, deletion and mailing the files. Each file can be rotated daily, weekly or monthly basis or when the file size becomes too large.

Main logrotate configuration is in /etc/logrotate.conf .If you look into that file which has configuration many default configuration. Before we dive into the configuration you should see below line in the file.

include /etc/logrotate.d/

Rather than writing all the process log into single file, let's create a separate configuration file so that it will be easy to maintain.First, we need to create an nginx conf file inside /etc/logrotate.d/

cd /etc/logrotate.d/
sudo touch nginx

Let's write the below basic configuration into that file and save it. I will run you through what each line does.

/etc/nginx/log/*.log {
  daily
  rotate 15
  missingok
  compress
  delaycompress
  notifempty
  dateext
  dateformat .%Y-%m-%d
  create 664 www-data www-data
  sharedscripts
  postrotate
    [ ! -f /var/run/nginx.pid ] || kill -USR1 `cat /var/run/nginx.pid`
  endscript
}

/etc/nginx/log/*.log : Is the path of logs file you want to rotate.
daily : Rotate on a daily basis.
size : (100K/100M/100G) This will logrotate the log whenever the size of the file increases as configured.
rotate 15: Only last 15 log file are kept and others will be deleted. If rotate count is 0 old versions are deleted rather than rotated
missingok : If the log file is missing move to next file without throwing error.
nomissingok : If log file doesn't exist throw an error.
compress : It compresses the rotated file by default it uses gzip and file formats ending with .gz.
delaycompress: Delaycompress as the name suggest it delays compression of the log file so that previous processes after a restart or reload will be still written in the old log file so that we don't miss any logs. This will only work if you have compress in the configuration.
notifempty : Do not rotate the file if it's empty.
dateext : Archiving the old log file with date extension rather than by number. Format for a daily extension is YYYYMMDD. This is really handy when you need to search anything on a specific date.
create mode owner group: This creates a new log file with mode, owner, and the group immediately after rotation.
dateformat : To specify the date format extension to dateext.
sharedscripts : Sharedscripts are used with postrotate or prerotate, any scripts added to the postscript to run only once.
postrotate : Script inside the postrotate and endscript are executed after the logfile is rotated. This script does not kill the nginx process instead it sends a signal to reload the log files so that new requests are logged in the new file.
prerotate : Script inside this block will be executed before the logrotate.

This tutorial is just to get you started with logrotate. There are many configurations in logrotate like mailing the logs to the specific email address and many more. I encourage to check the inbuild documentation(man logratote)

Welcome to Nginx! (Part-II)

shiva kumar — Fri, 12 Apr 2019 06:47:24 +0000

This post is the continuation of Part-I. If you haven't read that article, I recommend to read that.

By default nginx has some folders and files as shown below.

We are interested into two main folders

1) /etc/nginx/conf - Where our most of the configuration goes
2) /etc/nginx/logs - Server logs files resides there. They are access.log and error.log files

Lets dive into conf folder first. Conf Folder has many .conf files as mentioned below, which are for different protocols

i) fastcgi.conf - This configuration is used for fastcgi protocol application
ii) nginx.conf - This is configuration we are interested in, we will break down this file and go in details regarding the configuration
iii) scgi_params - This file is used for passing request to an SCGI server
iv) uwsgi_params - This file is used for processing request to the uwsgi application e.g used with python application
v) mime.types - Multi Internet Mail Extension which has list of formats to support email and http

Log folder has error.log and access.log. Each request gets logged in access log and whenever a request throws a error that gets logged in error.log

Nginx configuration file consist of two main things, Directives and Contexts. Directives are simple single line configuration which ends with semi-colon and Contexts are top level directives that are grouped together with multiple directives.

Example of Directives are

user www-data;
include conf.d/first_nginx.conf;

There are four main context

1) events - connection processing
2) http - for serving http/https traffic
3) mail - for serving mail traffic
4) stream - for steaming TCP and UDP packets

Let's create a simple static page and let's configure it with nginx to access across the internet. First, let's put our project inside a folder and create a homepage.html

mkdir apps && cd apps && mkdir welcome
cd welcome && touch homepage.html

Now that we have created our welcome page now let's configure this to nginx.Instead of writing inside the default nginx.conf. We are going to create a separate configuration file called
first_nginx.conf inside /etc/nginx/conf/ . If you remember from the first post this is where we installed the nginx. Let's add below configuration and save

server {
  listen 80;
  # on which port nginx should listen for request


  server_name  server_ip;
  # domain name or ip address of the server

  root         /home/ubuntu/apps/welcome/;
  # path where the project resides

  index homepage.html;
  # default page to load

}

Now let go to default nginx.conf file and include our first nginx configuration file inside http context. I have tried to explain each directive and context in single line comment

#user  nginx;
# user and group credentials used by worker_process if a group is not specified it will be equal to the user

worker_processes  1;
# Define the number of worker_processes, an optimal value would be the number of CPU cores in the server or set to auto

#pid        logs/nginx.pid;

events {
    worker_connections  1024;
    #Number of maximum connection can be opened by one worker process concurrently

}


http {
    include       mime.types;
    default_type  application/octet-stream;
    # This means the response is a binary file, if it is not specified the response is set to text/plain


    #log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
    #                  '$status $body_bytes_sent "$http_referer" '
    #                  '"$http_user_agent" "$http_x_forwarded_for"';

    # Formatting the request data log we can configure the parameter we need in     the log.

    #access_log  logs/access.log  main;

    client_max_body_size 20M;
    # configuration to set max client body size, if the request body is greater than 20M 
    # (413 status code) Request Entity Too Large is return to client


    keepalive_timeout  65;
    # for how many seconds the connection to be alive if it takes more the 65s to process it will connection time out

    include /etc/nginx/conf/first_nginx.conf;
    # Rather than writing the all the configuration, we can write the configuration in different and include in # the default conf file to make it easier to maintain

    #gzip  on;
    # compresses the response using gzip be default it is off
}

Now we are going to restart the server

sudo service nginx restart

Enter the ip address of the server in the browser .... ta-da. You did it NNN(Novice Nginx Ninja 👨🏻‍💻 )

Welcome To Nginx! (Part-I)

shiva kumar — Mon, 08 Apr 2019 08:30:18 +0000

What is Nginx?

According to Wiki, Nginx is an open source web server which can also be used as a reverse proxy, load balancer, mail proxy, and HTTP cache. The software was created by Igor Sysoev and first publicly released in 2004. Nginx claims to run 60% of the busiest website on the internet.
We use Nginx mostly as a web server(with the passenger for Rails or golang application) and as a load balancer.

How to install Nginx in Ubuntu?

Two ways to install Nginx one is from the package and other is from source(recommended)

Installing from the package is very simple. This will install the latest stable version
```
$ sudo apt-get install nginx

$ sudo nginx -v
  nginx version: nginx/1.10.2
```
Installing Nginx from source. There are few dependencies we need to install before installing Nginx
```
$ sudo apt-get install libpcre3-dev build-essential libssl-dev
```
1. libpcre3-dev -> This is basically a regular expression library
2. libssl-dev -> This package is part of OpenSSL implementation of the SSL and TLS for a secure connection
3. build-essentail -> This package includes GNU C++ compiler, GNU C compiler and other libraries

You can install on any preferred location, mostly it's installed in /opt or /etc

    $ cd /etc/

    $ sudo wget http://nginx.org/download/nginx-1.10.2.tar.gz

Unzipping the tar file

    $ sudo tar -zxvf nginx-1.10.2.tar.gz

    $ cd /etc/nginx-1.10.2

Configure the build

    $ sudo ./configure --prefix=/etc/nginx --user=nginx --group=nginx --with-http_ssl_module

    Configuration summary
  + using system PCRE library
  + using system OpenSSL library
  + md5: using OpenSSL library
  + sha1: using OpenSSL library
  + using system zlib library

  nginx path prefix: "/etc/nginx"
  nginx binary file: "/etc/nginx/sbin/nginx"
  nginx modules path: "/etc/nginx/modules"
  nginx configuration prefix: "/etc/nginx/conf"
  nginx configuration file: "/etc/nginx/conf/nginx.conf"
  nginx pid file: "/etc/nginx/logs/nginx.pid"
  nginx error log file: "/etc/nginx/logs/error.log"
  nginx http access log file: "/etc/nginx/logs/access.log"
  nginx http client request body temporary files: "client_body_temp"
  nginx http proxy temporary files: "proxy_temp"
  nginx http fastcgi temporary files: "fastcgi_temp"
  nginx http uwsgi temporary files: "uwsgi_temp"
  nginx http scgi temporary files: "scgi_temp"

Let's build and install with the above configuration

    $ sudo make 
    $ sudo make install

We need to create a separate user and group for Nginx

    $ sudo adduser --system --no-create-home --disabled-login --disabled-password --group nginx

Installing from source does not include init file for starting and stop the Nginx during the server reboots

    $ sudo vi /etc/init.d/nginx

Make the above file executable and add it to default run levels

    $ sudo chmod +x /etc/init.d/nginx
    $ sudo /usr/sbin/update-rc.d -f nginx defaults

Now we can start, stop, restart and check status using the below command

    $ sudo service nginx <command>

command -> start, stop, restart, status

You can check if nginx is running using the below command or by visiting the ip address where you have installed

    $ ps aux | grep nginx

Congratulation! You have successfully installed Nginx.

Part II will be about, what different files inside the conf folder does, configuring Nginx to serve an application and what's the role of each block inside nginx.conf file.