Gentoo LEMP-ൽ FcgiWrap ഇൻസ്റ്റാൾ ചെയ്യുകയും Perl, Ruby, Bash ഡൈനാമിക് ഭാഷകൾ പ്രവർത്തനക്ഷമമാക്കുകയും ചെയ്യുന്നു
ഈ ട്യൂട്ടോറിയൽ Gentoo-ലെ LEMP ഇൻസ്റ്റാളേഷനിൽ മുമ്പത്തേതുമായി കർശനമായി ബന്ധപ്പെട്ടിരിക്കുന്നു, കൂടാതെ Fcgiwrap ഗേറ്റ്uവേയിലൂടെ Perl അല്ലെങ്കിൽ Bash അല്ലെങ്കിൽ Ruby പോലുള്ള ഡൈനാമിക് സ്uക്രിപ്റ്റിംഗ് ഭാഷകൾ പ്രവർത്തനക്ഷമമാക്കുന്നത് പോലെയുള്ള മറ്റ് സെർവർ വിപുലീകൃത പ്രശ്നങ്ങൾ കൈകാര്യം ചെയ്യുന്നു, കൂടാതെ ഡൈനാമിക് ഉള്ളടക്കം നൽകുന്നതിന് Nginx വെർച്വൽ ഹോസ്റ്റ് കോൺഫിഗറേഷൻ ഫയലുകൾ എഡിറ്റ് ചെയ്യുന്നു .pl, .rb, .cgi സ്ക്രിപ്റ്റുകൾ.
- ജെന്റൂവിൽ LEMP സ്റ്റാക്ക് ഇൻസ്റ്റാൾ ചെയ്തു – https://linux-console.net/install-lemp-in-gentoo-linux/
ഘട്ടം 1: Gentoo LEMP-ൽ FCGIWRAP പ്രവർത്തനക്ഷമമാക്കുക
Fcgiwrap എന്നത് Nginx FastCGI കോമൺ ഗേറ്റ്uവേ ഇന്റർഫേസിന്റെ ഭാഗമാണ്, ഇത് മറ്റ് ഡൈനാമിക് സ്uക്രിപ്റ്റിംഗ് ഭാഷകളായ Perl അല്ലെങ്കിൽ Bash അല്ലെങ്കിൽ Ruby സ്uക്രിപ്റ്റുകൾ പ്രോസസ്സ് ചെയ്യുന്നു, ഇത് Nginx-ൽ നിന്ന് ലഭിക്കുന്ന അഭ്യർത്ഥനകൾ TCP വഴി പ്രോസസ്സ് ചെയ്തുകൊണ്ട് പ്രവർത്തിക്കുന്നു. Unix Sockets, സ്വതന്ത്രമായ രീതിയിൽ, ഉൽപ്പാദിപ്പിച്ച ഫലം Nginx-ലേക്ക് തിരികെ നൽകുന്നു, ഇത് പദത്തിൽ, അന്തിമ ക്ലയന്റുകളിലേക്ക് പ്രതികരണങ്ങൾ കൈമാറും.
1. താഴെ പറയുന്ന കമാൻഡ് ഉപയോഗിച്ച് Gentoo Linux-ൽ FCcgiwrap പ്രോസസ്സ് ഇൻസ്റ്റാൾ ചെയ്തുകൊണ്ട് നമുക്ക് ആദ്യം ആരംഭിക്കാം.
# emerge --ask www-misc/fcgiwrap
2. ഡിഫോൾട്ടായി Fcgiwrap പാക്കേജ്, പ്രോസസ്സ് മാനേജ് ചെയ്യുന്നതിനായി ജെന്റൂവിൽ init സ്ക്രിപ്റ്റുകളൊന്നും നൽകുന്നില്ല. പാക്കേജുകൾ കംപൈൽ ചെയ്uത് ഇൻസ്റ്റാൾ ചെയ്uത ശേഷം, ഇനിപ്പറയുന്ന init സ്uക്രിപ്റ്റുകൾ സൃഷ്uടിക്കുക, അത് മൂന്ന് സമീപനങ്ങൾ ഉപയോഗിച്ച് Fcgiwrap പ്രോസസ്സ് നിയന്ത്രിക്കാൻ നിങ്ങളെ സഹായിക്കുന്നു: ഒന്നുകിൽ Unix Domain Sockets ഉപയോഗിച്ചോ ലോക്കൽ < ഉപയോഗിച്ചോ പ്രോസസ് സമാരംഭിക്കുക. b>TCP സോക്കറ്റുകൾഅല്ലെങ്കിൽ രണ്ടും ഒരേ സമയം ഉപയോഗിക്കുന്നു.
ഇനിപ്പറയുന്ന ഫയൽ ഉള്ളടക്കം ഉപയോഗിച്ച് /etc/init.d/ പാതയിൽ ഒരു init ഫയൽ സൃഷ്uടിക്കുക.
# nano /etc/init.d/fcgiwrap
ഇനിപ്പറയുന്ന ഫയൽ ഉള്ളടക്കം ചേർക്കുക.
#!/sbin/runscript
ip="0.0.0.0"
port="12345"
start() {
ebegin "Starting fcgiwrap process..."
/usr/sbin/fcgiwrap -s tcp:$ip:$port &
tcp_sock=`netstat -tulpn | grep fcgiwrap`
echo "Socket details: $tcp_sock"
eend $? "Errors were encountered while starting fcgiwrap process"
}
stop() {
ebegin "Stopping fcgiwrap process..."
pid=`ps a | grep fcgiwrap | grep tcp | cut -d" " -f1`
kill -s 1 $pid
tcp_sock=`netstat -tulpn | grep fcgiwrap`
if test $tcp_sock = 2> /dev/null ; then
echo "Fcgiwrap process successfully stoped"
tcp_sock=`netstat -atulpn | grep $port`
if test $tcp_sock = 2> /dev/null ; then
echo "No open fcgiwrap connection found..."
else
echo "Wait to close fcgiwrap open connections...please verify with 'status'"
echo -e "Socket details: \n$tcp_sock"
fi
else
echo "Fcgiwarp process is still running!"
echo "Socket details: $tcp_sock"
fi
eend $? "Errors were encountered while stopping fcgiwrap process..."
}
status() {
ebegin "Status fcgiwrap process..."
tcp_sock=`netstat -atulpn | grep $port`
if test $tcp_sock = 2> /dev/null ; then
echo "Fcgiwrap process not running"
else
echo "Fcgiwarp process is running!"
echo -e "Socket details: \n$tcp_sock"
fi
eend $? "Errors were encountered while stopping fcgiwrap process..."
}
നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, സ്uക്രിപ്റ്റ് ഫയലിൽ യഥാക്രമം ip, port എന്നീ രണ്ട് വേരിയബിൾ ഉണ്ട്. നിങ്ങളുടെ സ്വന്തം ആവശ്യങ്ങൾക്കനുസരിച്ച് ഈ വേരിയബിളുകൾ മാറ്റുകയും അവ നിങ്ങളുടെ സിസ്റ്റത്തിലെ മറ്റ് സേവനങ്ങളുമായി ഓവർലാപ്പ് ചെയ്യുന്നില്ലെന്ന് ഉറപ്പാക്കുകയും ചെയ്യുക, പ്രത്യേകിച്ച് പോർട്ട് വേരിയബിൾ - ഇവിടെ സ്ഥിരസ്ഥിതി 12345 ആണ് - അതിനനുസരിച്ച് മാറ്റുക.
IP വേരിയബിളിൽ 0.0.0.0 ഉപയോഗിക്കുന്നത് ഏത് ഐപിയിലും ബൈൻഡ് ചെയ്യാനും കേൾക്കാനും പ്രക്രിയയെ പ്രാപ്തമാക്കുന്നു (നിങ്ങൾക്ക് ഒരു ഫയർവാൾ ഇല്ലെങ്കിൽ പുറത്ത് ആക്uസസ് ചെയ്യാനാകും), എന്നാൽ സുരക്ഷാ കാരണങ്ങളാൽ പ്രാദേശികമായി മാത്രം കേൾക്കാൻ നിങ്ങൾ അത് മാറ്റണം, 127.0.0.1-ൽ, പ്രകടനത്തിനോ ലോഡ് ബാലൻസിനോ വേണ്ടി മറ്റൊരു നോഡിൽ Fcgiwrap ഗേറ്റ്uവേ വിദൂരമായി സജ്ജീകരിക്കുന്നത് പോലുള്ള മറ്റ് കാരണങ്ങളില്ലെങ്കിൽ.
3. ഫയൽ സൃഷ്ടിച്ച ശേഷം, എക്സിക്യൂഷൻ പെർമിഷനുകൾ ചേർക്കുകയും സ്റ്റാർട്ട്, സ്റ്റോപ്പ് അല്ലെങ്കിൽ സ്റ്റാറ്റസ് സ്വിച്ചുകൾ ഉപയോഗിച്ച് ഡെമൺ പ്രോസസ്സ് നിയന്ത്രിക്കുകയും ചെയ്യുക. സ്റ്റാറ്റസ് സ്വിച്ച്, അത് കേൾക്കുന്ന IP-PORT ജോടി പോലെയുള്ള പ്രസക്തമായ സോക്കറ്റ് വിവരങ്ങൾ കാണിക്കും, കൂടാതെ എന്തെങ്കിലും സജീവമായ കണക്ഷൻ ആരംഭിച്ചിട്ടുണ്ടെങ്കിൽ. കൂടാതെ, പ്രോസസ്സിന് TIME_WAIT അവസ്ഥയിൽ സജീവമായ കണക്ഷനുകൾ ഉണ്ടെങ്കിൽ, എല്ലാ TCP കണക്ഷനുകളും അടയ്ക്കുന്നത് വരെ നിങ്ങൾക്ക് അത് പുനരാരംഭിക്കാനാകില്ല.
# chmod +x /etc/init.d/fcgiwrap # service start fcgiwrap # /etc/init.d/fcgiwrap status
നേരത്തെ അവതരിപ്പിച്ചത് പോലെ Fcgiwrap രണ്ട് സോക്കറ്റുകളും ഉപയോഗിച്ച് ഒരേസമയം പ്രവർത്തിക്കാൻ കഴിയും, അതിനാൽ രണ്ടും ഒരേ സമയം ആരംഭിക്കാനും പ്രവർത്തിപ്പിക്കാനും കഴിയുമെന്ന് ഉറപ്പാക്കാൻ രണ്ടാമത്തെ സ്ക്രിപ്റ്റിന്റെ പേര് fcgiwrap-unix-socket എന്നാക്കി മാറ്റും.
# nano /etc/init.d/fcgiwrap-unix-socket
UNIX സോക്കറ്റിനായി ഇനിപ്പറയുന്ന ഫയൽ ഉള്ളടക്കം ഉപയോഗിക്കുക.
#!/sbin/runscript
sock_detail=`ps a | grep fcgiwrap-unix | head -1`
start() {
ebegin "Starting fcgiwrap-unix-socket process..."
/usr/sbin/fcgiwrap -s unix:/run/fcgiwrap-unix.sock &
sleep 2
/bin/chown nginx:nginx /run/fcgiwrap-unix.sock
sleep 1
sock=`ls -al /run/fcgiwrap-unix.sock`
echo "Socket details: $sock"
eend $? "Errors were encountered while starting fcgiwrap process"
}
stop() {
ebegin "Stopping fcgiwrap-unix-socket process..."
pid=`ps a | grep fcgiwrap | grep unix | cut -d" " -f1`
rm -f /run/fcgiwrap-unix.sock
kill -s 1 $pid
echo "Fcgiwrap process successfully stoped"
#killall /usr/sbin/fcgiwrap
sleep 1
echo "Socket details: $sock"
eend $? "Errors were encountered while stopping fcgiwrap process..."
}
status() {
ebegin "Status fcgiwrap-unix-socket process..."
if test -S /run/fcgiwrap-unix.sock; then
echo "Process is started with socket: $sock_detail"
else
echo "Fcgiwrap process not running!"
fi
eend $? "Errors were encountered while stopping fcgiwrap process..."
}
4. ഈ ഫയൽ എക്സിക്യൂട്ടബിൾ ആണെന്ന് വീണ്ടും ഉറപ്പുനൽകുകയും അതേ സേവന സ്വിച്ചുകൾ ഉപയോഗിക്കുക: ആരംഭിക്കുക, സ്റ്റോപ്പ് അല്ലെങ്കിൽ സ്റ്റാറ്റസ്. ഞാൻ ഈ സോക്കറ്റിനായി /run/fcgiwrap-unix.sock സിസ്റ്റം പാതയിൽ സ്ഥിരസ്ഥിതി പാത്ത് സജ്ജമാക്കി. പ്രക്രിയ ആരംഭിച്ച് സ്റ്റാറ്റസ് ഉപയോഗിച്ച് അത് പരിശോധിച്ചുറപ്പിക്കുക അല്ലെങ്കിൽ /run ഡയറക്uടറി ഉള്ളടക്കം ലിസ്റ്റ് ചെയ്യുക, സോക്കറ്റ് കണ്ടെത്തുക, അല്ലെങ്കിൽ ps -a | grep fcgiwrapകമാൻഡ്.
# chmod +x /etc/init.d/fcgiwrap-unix-socket # service start fcgiwrap-unix-socket # /etc/init.d/fcgiwrap-unix-socket status # ps -a | grep fcgiwrap
മുമ്പ് സൂചിപ്പിച്ചതുപോലെ, Fcgiwrap-ന് ഒരേസമയം TCP, UNIX സോക്കറ്റുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ കഴിയും, എന്നാൽ നിങ്ങൾക്ക് ബാഹ്യ ഗേറ്റ്uവേ കണക്ഷനുകൾ ആവശ്യമില്ലെങ്കിൽ Unix Domain Socket-ൽ മാത്രം ഉറച്ചുനിൽക്കുക, കാരണം അത് ഇന്റർപ്രോസസ് കമ്മ്യൂണിക്കേഷൻ ഉപയോഗിക്കുന്നു, ഇത് ആശയവിനിമയത്തേക്കാൾ വേഗതയുള്ളതാണ്. ടിസിപി ലൂപ്പ്ബാക്ക് കണക്ഷനുകൾ, കൂടാതെ കുറച്ച് ടിസിപി ഓവർഹെഡ് ഉപയോഗിക്കുന്നു.
ഘട്ടം 2: Nginx-ൽ CGI സ്ക്രിപ്റ്റുകൾ പ്രവർത്തനക്ഷമമാക്കുക
5. ഫാസ്റ്റ് കോമൺ ഗേറ്റ്uവേ ഇന്റർഫേസിലൂടെ Nginx-ന് Perl അല്ലെങ്കിൽ Bash സ്uക്രിപ്റ്റുകൾ പാഴ്uസ് ചെയ്യാനും പ്രവർത്തിപ്പിക്കാനും, റൂട്ട് പാഥിലോ ലൊക്കേഷൻ സ്റ്റേറ്റ്uമെന്റുകളിലോ Fcgiwrap നിർവചനങ്ങൾ ഉപയോഗിച്ച് വെർച്വൽ ഹോസ്റ്റുകൾ കോൺഫിഗർ ചെയ്തിരിക്കണം.
ഒരു ഉദാഹരണം ചുവടെ അവതരിപ്പിച്ചിരിക്കുന്നു (ലോക്കൽഹോസ്റ്റ്), ഇത് .pl/var/www/localhost/htdocs/) സ്ഥാപിച്ചിട്ടുള്ള എല്ലാ ഫയലുകളിലും Perl, CGI സ്ക്രിപ്റ്റുകൾ സജീവമാക്കുന്നു. ഡിഫോൾട്ട് റൂട്ട് ഡോക്യുമെന്റ് പാത്തിന് Fcgiwrap TCP സോക്കറ്റുകൾ ഉപയോഗിച്ച് > കൂടാതെ .cgi വിപുലീകരണവും, index.pl ഫയൽ ഉള്ള Unix Domain Sockets ഉപയോഗിക്കുന്ന രണ്ടാമത്തെ ലൊക്കേഷനും മൂന്നാമത്തെ ലൊക്കേഷൻ ഒരു index.cgi ഫയലിനൊപ്പം TCP സോക്കറ്റുകൾ ഉപയോഗിക്കുന്നു.
fastcgi_pass ആർഗ്യുമെന്റ് സ്റ്റേറ്റ്uമെന്റ് പരിഷ്uക്കരിച്ച് വ്യത്യസ്ത ലൊക്കേഷനുകൾക്ക് കീഴിൽ UNIX അല്ലെങ്കിൽ TCP സോക്കറ്റുകൾ ഉപയോഗിച്ച് ഡൈനാമിക് പേൾ അല്ലെങ്കിൽ ബാഷ് സ്uക്രിപ്റ്റുകൾ സജീവമാക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്ന വെർച്വൽ ഹോസ്റ്റ് കോൺഫിഗറേഷൻ ഫയലിലേക്ക് ഇനിപ്പറയുന്ന ഉള്ളടക്കം അല്ലെങ്കിൽ അതിന്റെ ചില ഭാഗങ്ങൾ സ്ഥാപിക്കുക.
# nano /etc/nginx/sites-available/localhost.conf
ചുവടെയുള്ള ടെംപ്ലേറ്റിലെ പോലെ കാണുന്നതിന് localhost.conf എഡിറ്റ് ചെയ്യുക.
server {
listen 80;
server_name localhost;
access_log /var/log/nginx/localhost_access_log main;
error_log /var/log/nginx/localhost_error_log info;
root /var/www/localhost/htdocs/;
location / {
autoindex on;
index index.html index.htm index.php;
}
## PHP –FPM Gateway ###
location ~ \.php$ {
try_files $uri =404;
include /etc/nginx/fastcgi.conf;
fastcgi_pass 127.0.0.1:9001;
}
## Fcgiwrap Gateway on all files under root with TCP Sockets###
location ~ \.(pl|cgi|rb)$ {
fastcgi_index index.cgi index.pl;
include /etc/nginx/fastcgi.conf;
fastcgi_pass 127.0.0.1:12345;
}
## Fcgiwrap Gateway on all files under root second folder with index.pl using UNIX Sockets###
location /second {
index index.pl;
root /var/www/localhost/htdocs/;
location ~ \.(pl|cgi|rb)$ {
include /etc/nginx/fastcgi.conf;
fastcgi_pass unix:/run/fcgiwrap-unix.sock;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
}
}
## Fcgiwrap Gateway on all files under root third folder with index.cgi using TCP Sockets###
location /third {
index index.cgi;
location ~ \.(pl|cgi|rb)$ {
include /etc/nginx/fastcgi.conf;
fastcgi_pass 127.0.0.1:12345;
}
}6. നിങ്ങൾ Nginx localhost.conf അല്ലെങ്കിൽ നിങ്ങളുടെ നിർദ്ദിഷ്ട വെർച്വൽ ഹോസ്റ്റ് കോൺഫിഗറേഷൻ ഫയൽ എഡിറ്റുചെയ്യുന്നത് പൂർത്തിയാക്കിയ ശേഷം, നിങ്ങളുടെ വെബ്uസൈറ്റ് ഡിഫോൾട്ട് ഡോക്യുമെന്റ് റൂട്ട് പാഥിലേക്ക് നീങ്ങുക, നിങ്ങളുടെ ലൊക്കേഷൻ സ്റ്റേറ്റ്uമെന്റ് പ്രതിഫലിപ്പിക്കുന്നതിന് ആ രണ്ട് ഫോൾഡറുകൾ സൃഷ്uടിക്കുക, കൂടാതെ ഇൻഡക്സ് ഫയലുകൾ സൃഷ്ടിക്കുക ഓരോ സ്ഥലവും അതിന്റേതായ വിപുലീകരണത്തോടെ.
# cd /var/www/localhost/htdocs # mkdir second third
ഇനിപ്പറയുന്ന ഉള്ളടക്കം ഉപയോഗിച്ച് രണ്ടാമത്തെ ലൊക്കേഷനിൽ index.pl ഫയൽ സൃഷ്uടിക്കുക.
# nano /var/www/localhost/htdocs/second/index.pl
പരിസ്ഥിതി വേരിയബിളുകൾ ലഭിക്കാൻ ഈ ഉള്ളടക്കം ചേർക്കുക.
#!/usr/bin/perl
print "Content-type: text/html\n\n";
print <<HTML;
<html>
<head><title>Perl Index</title></head>
<body>
<div align=center><h1>A Perl CGI index on second location with env variables</h1></div>
</body>
HTML
print "Content-type: text/html\n\n"; foreach my $keys (sort keys %ENV) { print "$keys =
$ENV{$keys}<br/>\n";
}
exit;തുടർന്ന് ഇനിപ്പറയുന്ന ഉള്ളടക്കം ഉപയോഗിച്ച് മൂന്നാം സ്ഥാനത്ത് index.cgi ഫയൽ സൃഷ്ടിക്കുക.
# nano /var/www/localhost/htdocs/third/index.cgi
പരിസ്ഥിതി വേരിയബിളുകൾ ലഭിക്കാൻ ഈ ഉള്ളടക്കം ചേർക്കുക.
#!/bin/bash echo Content-type: text/html echo "" cat << EOF <HTML> <HEAD><TITLE>Bash script</TITLE></HEAD> <BODY><PRE> <div align=center><h1>A BASH CGI index on third location with env variables</h1></div> EOF env cat << EOF </BODY> </HTML> EOF
7. എഡിറ്റിംഗ് പൂർത്തിയാക്കുമ്പോൾ, രണ്ട് ഫയലുകളും എക്സിക്യൂട്ടബിൾ ആക്കുക, Nginx സെർവർ പുനരാരംഭിക്കുക, കൂടാതെ രണ്ട് Fcgiwrap സോക്കറ്റുകളും പ്രവർത്തിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കുക.
# chmod +x /var/www/localhost/htdocs/second/index.pl # chmod +x /var/www/localhost/htdocs/third/index.cgi # service nginx restart # service fcgiwrap start # service fcgiwrap-unix-socket start
അടുത്തതായി, ഇനിപ്പറയുന്ന URL-ലേക്ക് നിങ്ങളുടെ പ്രാദേശിക ബ്രൗസർ റീഡയറക്uട് ചെയ്യുക.
http://localhost http://localhost/second/ http://localhost/third/
ഫലം ചുവടെയുള്ള സ്ക്രീൻഷോട്ടുകളിൽ ദൃശ്യമാകണം.
8. എല്ലാം ശരിയായി ക്രമീകരിച്ചിട്ടുണ്ടെങ്കിൽ, ഇനിപ്പറയുന്ന കമാൻഡുകൾ നൽകി (രണ്ട് CGI സോക്കറ്റുകളും ഉപയോഗിക്കുന്നതിന് നിങ്ങൾ Nginx കോൺഫിഗർ ചെയ്uതിട്ടുണ്ടെങ്കിൽ) റീബൂട്ട് ചെയ്uതതിന് ശേഷം, രണ്ട് Fcgiwrap ഡെമണുകളും സ്വയമേവ ആരംഭിക്കാൻ പ്രാപ്uതമാക്കുക.
# rc-update add fcgiwrap default # rc-update add fcgiwrap-unix-socket default
ഘട്ടം 3: Fcgiwrap-ൽ Ruby പിന്തുണ സജീവമാക്കുക
9. നിങ്ങൾക്ക് Nginx FCGI-യിൽ ഡൈനാമിക് റൂബി സ്ക്രിപ്റ്റുകൾ പ്രവർത്തിപ്പിക്കണമെങ്കിൽ, താഴെ പറയുന്ന കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾ ജെന്റൂവിൽ Ruby വ്യാഖ്യാതാവ് ഇൻസ്റ്റാൾ ചെയ്യണം.
# emerge --ask ruby
10. പാക്കേജ് കംപൈൽ ചെയ്ത് ഇൻസ്റ്റാൾ ചെയ്ത ശേഷം, Nginx sites-available എന്നതിലേക്ക് നീങ്ങുക, അവസാന ചുരുണ്ട ബ്രാക്കറ്റിന് മുമ്പായി ഇനിപ്പറയുന്ന പ്രസ്താവനകൾ ചേർത്തുകൊണ്ട് localhost.conf ഫയൽ എഡിറ്റ് ചെയ്യുക \ } ”, Nginx ലോക്കൽ ഹോസ്റ്റ് നൽകുന്ന ഡിഫോൾട്ട് ഡോക്യുമെന്റ് റൂട്ട് പാത്തിന് കീഴിൽ നാലാമത്തെ ലൊക്കേഷനിൽ റൂബി സ്ക്രിപ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള പിന്തുണ സജീവമാക്കുന്നു.
# nano /etc/nginx/sites-available/localhost.conf
ഇനിപ്പറയുന്ന Nginx നിർദ്ദേശങ്ങൾ ഉപയോഗിക്കുക.
## Fcgiwrap Gateway on all files under root fourth folder with index.rb under TCP Sockets###
location /fourth {
index index.rb;
location ~ \.rb$ {
include /etc/nginx/fastcgi.conf;
fastcgi_pass 127.0.0.1:12345;
}
}
## Last curly bracket which closes Nginx server definitions ##
}
11. ഇപ്പോൾ, കോൺഫിഗറേഷൻ പരിശോധിക്കുന്നതിനായി, /var/www/localhost/htdocs പാത്തിന് കീഴിൽ നാലാമത്തെ ഡയറക്uടറി സൃഷ്uടിക്കുക, .rb വിപുലീകരണത്തോടുകൂടിയ ഒരു എക്uസിക്യൂട്ടബിൾ റൂബി സൂചിക സ്uക്രിപ്റ്റ് സൃഷ്uടിച്ച് ഇനിപ്പറയുന്നവ ചേർക്കുക ഉള്ളടക്കം.
# mkdir /var/www/localhost/htdocs/fourth # nano /var/www/localhost/htdocs/fourth/index.rb
Ruby index.rb ഉദാഹരണം.
#!/usr/bin/ruby
puts "HTTP/1.0 200 OK"
puts "Content-type: text/html\n\n"
puts "<html><HEAD><TITLE>Ruby script</TITLE></HEAD>"
puts "<BODY><PRE>"
puts "<div align=center><h1>A Ruby CGI index on fourth location with env variables</h1></div>"
system('env')12. നിങ്ങൾ ഫയലിൽ എക്സിക്യൂഷൻ അനുമതികൾ ചേർത്ത ശേഷം, കോൺഫിഗറേഷനുകൾ പ്രയോഗിക്കുന്നതിന് Nginx ഡെമൺ പുനരാരംഭിക്കുക.
# chmod +x /var/www/localhost/htdocs/fourth/index.rb # service nginx restart
നിങ്ങളുടെ ബ്രൗസർ തുറന്ന് http://localhost/fourth/ എന്ന URL-ലേക്ക് നാവിഗേറ്റ് ചെയ്യുക, അത് നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന ഉള്ളടക്കം നൽകും.
ഇപ്പോൾ അത്രയേയുള്ളൂ, FastCGI ഗേറ്റ്uവേയിൽ ഡൈനാമിക് പെർൾ, റൂബി, ബാഷ് സ്uക്രിപ്റ്റുകൾ നൽകുന്നതിന് നിങ്ങൾ Nginx കോൺഫിഗർ ചെയ്uതു, പക്ഷേ, Nginx CGI ഗേറ്റ്uവേയിൽ ഇത്തരത്തിലുള്ള വ്യാഖ്യാന സ്uക്രിപ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുന്നത് അപകടകരവും ഗുരുതരമായ സുരക്ഷാ അപകടസാധ്യതകൾ നിങ്ങളുടെ സെർവറിൽ അടിച്ചേൽപ്പിക്കുന്നതും ആണെന്ന് ശ്രദ്ധിക്കുക. നിങ്ങളുടെ സിസ്റ്റത്തിന് കീഴിലുള്ള സജീവ ഷെല്ലുകൾ ഉപയോഗിച്ച് പ്രവർത്തിപ്പിക്കുക, എന്നാൽ നിങ്ങളുടെ വെബ്uസൈറ്റിലേക്ക് ചലനാത്മകമായ പ്രവർത്തനം ചേർത്ത് സ്റ്റാറ്റിക് HTML ചുമത്തുന്ന സ്റ്റാറ്റിക് തടസ്സം വികസിപ്പിക്കാൻ കഴിയും.