વર્કશોપ RHEL 8 બીટા: કાર્યરત વેબ એપ્લિકેશન્સનું નિર્માણ

RHEL 8 બીટા વિકાસકર્તાઓને ઘણી નવી સુવિધાઓ પ્રદાન કરે છે, જેની સૂચિ પૃષ્ઠો લઈ શકે છે, જો કે, નવી વસ્તુઓ શીખવી હંમેશા વ્યવહારમાં વધુ સારી છે, તેથી નીચે અમે ખરેખર Red Hat Enterprise Linux 8 બીટા પર આધારિત એપ્લિકેશન ઈન્ફ્રાસ્ટ્રક્ચર બનાવવા પર વર્કશોપ ઓફર કરીએ છીએ.

ચાલો વિકાસકર્તાઓમાં લોકપ્રિય પ્રોગ્રામિંગ લેંગ્વેજ પાયથોનને આધાર તરીકે લઈએ, Django અને PostgreSQL, એપ્લીકેશન બનાવવા માટે એકદમ સામાન્ય સંયોજન, અને તેમની સાથે કામ કરવા માટે RHEL 8 Beta ને ગોઠવીએ. પછી અમે થોડા વધુ (અવર્ગીકૃત) ઘટકો ઉમેરીશું.

પરીક્ષણ વાતાવરણ બદલાશે, કારણ કે ઓટોમેશનની શક્યતાઓનું અન્વેષણ કરવું, કન્ટેનર સાથે કામ કરવું અને બહુવિધ સર્વર્સ સાથે પર્યાવરણને અજમાવવાનું રસપ્રદ છે. નવા પ્રોજેક્ટ સાથે પ્રારંભ કરવા માટે, તમે હાથથી એક નાનો, સરળ પ્રોટોટાઇપ બનાવીને પ્રારંભ કરી શકો છો જેથી તમે બરાબર જોઈ શકો કે શું થવાની જરૂર છે અને તે કેવી રીતે ક્રિયાપ્રતિક્રિયા કરે છે, અને પછી સ્વચાલિત કરવા અને વધુ જટિલ ગોઠવણીઓ બનાવવા માટે આગળ વધો. આજે આપણે આવા પ્રોટોટાઇપની રચના વિશે વાત કરી રહ્યા છીએ.

ચાલો આરએચઈએલ 8 બીટા વીએમ ઈમેજ જમાવીને શરૂઆત કરીએ. તમે શરૂઆતથી વર્ચ્યુઅલ મશીન ઇન્સ્ટોલ કરી શકો છો, અથવા તમારા બીટા સબ્સ્ક્રિપ્શન સાથે ઉપલબ્ધ KVM ગેસ્ટ ઈમેજનો ઉપયોગ કરી શકો છો. મહેમાન ઈમેજનો ઉપયોગ કરતી વખતે, તમારે વર્ચ્યુઅલ સીડીને રૂપરેખાંકિત કરવાની જરૂર પડશે કે જેમાં મેટાડેટા અને મેટાડેટાનો સમાવેશ થશે (ક્લાઉડ-ઈનિટ). તમારે ડિસ્ક સ્ટ્રક્ચર અથવા ઉપલબ્ધ પેકેજો સાથે કંઈ ખાસ કરવાની જરૂર નથી; કોઈપણ રૂપરેખાંકન કરશે.

ચાલો સમગ્ર પ્રક્રિયા પર નજીકથી નજર કરીએ.

Django ઇન્સ્ટોલ કરી રહ્યું છે

Django ના નવીનતમ સંસ્કરણ સાથે, તમારે Python 3.5 અથવા પછીના વર્ચ્યુઅલ પર્યાવરણ (virtualenv) ની જરૂર પડશે. બીટા નોંધોમાં તમે જોઈ શકો છો કે પાયથોન 3.6 ઉપલબ્ધ છે, ચાલો તપાસીએ કે આ ખરેખર કેસ છે કે કેમ:

[cloud-user@8beta1 ~]$ python
-bash: python: command not found
[cloud-user@8beta1 ~]$ python3
-bash: python3: command not found

Red Hat સક્રિયપણે RHEL માં સિસ્ટમ ટૂલકીટ તરીકે પાયથોનનો ઉપયોગ કરે છે, તો શા માટે આ પરિણામ આવે છે?

હકીકત એ છે કે ઘણા પાયથોન વિકાસકર્તાઓ હજી પણ પાયથોન 2 થી પાયથોન 2 માં સંક્રમણ વિશે વિચારી રહ્યા છે, જ્યારે પાયથોન 3 પોતે સક્રિય વિકાસ હેઠળ છે, અને વધુ અને વધુ નવા સંસ્કરણો સતત દેખાઈ રહ્યા છે. તેથી, Python ની વિવિધ નવી આવૃત્તિઓ માટે વપરાશકર્તાઓને ઍક્સેસ પ્રદાન કરતી વખતે સ્થિર સિસ્ટમ ટૂલ્સની જરૂરિયાતને પહોંચી વળવા માટે, સિસ્ટમ Python ને નવા પેકેજમાં ખસેડવામાં આવી હતી અને Python 2.7 અને 3.6 બંનેને ઇન્સ્ટોલ કરવાની ક્ષમતા પૂરી પાડી હતી. ફેરફારો અને તે શા માટે કરવામાં આવ્યા હતા તે વિશે વધુ માહિતી આમાંના પ્રકાશનમાં મળી શકે છે લેંગડન વ્હાઇટનો બ્લોગ (લેંગડોન વ્હાઇટ).

તેથી, કાર્યકારી Python મેળવવા માટે, તમારે ફક્ત બે પેકેજો ઇન્સ્ટોલ કરવાની જરૂર છે, જેમાં python3-pip ને નિર્ભરતા તરીકે શામેલ કરવામાં આવે છે.

sudo yum install python36 python3-virtualenv

શા માટે લેંગડોનના સૂચન મુજબ ડાયરેક્ટ મોડ્યુલ કોલનો ઉપયોગ ન કરવો અને pip3 ઇન્સ્ટોલ કરવું? આગામી ઓટોમેશનને ધ્યાનમાં રાખીને, તે જાણીતું છે કે Ansible ને ચલાવવા માટે pip ઇન્સ્ટોલ કરવાની જરૂર પડશે, કારણ કે pip મોડ્યુલ વૈવિધ્યપૂર્ણ પાઇપ એક્ઝિક્યુટેબલ સાથે વર્ચ્યુઅલેનવ્સને સપોર્ટ કરતું નથી.

તમારા નિકાલ પર કાર્યરત python3 દુભાષિયા સાથે, તમે Django ઇન્સ્ટોલેશન પ્રક્રિયા સાથે ચાલુ રાખી શકો છો અને અમારા અન્ય ઘટકો સાથે કાર્યકારી સિસ્ટમ ધરાવી શકો છો. ઇન્ટરનેટ પર ઘણા અમલીકરણ વિકલ્પો ઉપલબ્ધ છે. અહીં એક સંસ્કરણ પ્રસ્તુત છે, પરંતુ વપરાશકર્તાઓ તેમની પોતાની પ્રક્રિયાઓનો ઉપયોગ કરી શકે છે.

અમે Yum નો ઉપયોગ કરીને ડિફોલ્ટ રૂપે RHEL 8 માં ઉપલબ્ધ PostgreSQL અને Nginx વર્ઝન ઇન્સ્ટોલ કરીશું.

sudo yum install nginx postgresql-server

PostgreSQL ને psycopg2 ની જરૂર પડશે, પરંતુ તે ફક્ત વર્ચ્યુઅલેનવ વાતાવરણમાં જ ઉપલબ્ધ હોવું જરૂરી છે, તેથી અમે તેને Django અને Gunicorn સાથે pip3 નો ઉપયોગ કરીને ઇન્સ્ટોલ કરીશું. પરંતુ પહેલા આપણે વર્ચ્યુઅલેનવ સેટ કરવાની જરૂર છે.

Django પ્રોજેક્ટ્સ ઇન્સ્ટોલ કરવા માટે યોગ્ય સ્થાન પસંદ કરવાના વિષય પર હંમેશા ઘણી ચર્ચા થાય છે, પરંતુ જ્યારે શંકા હોય, ત્યારે તમે હંમેશા Linux ફાઇલસિસ્ટમ હાયરાર્કી સ્ટાન્ડર્ડ તરફ વળી શકો છો. ખાસ કરીને, એફએચએસ કહે છે કે /એસઆરવીનો ઉપયોગ આ માટે થાય છે: "હોસ્ટ-વિશિષ્ટ ડેટા સ્ટોર કરવા - ડેટા કે જે સિસ્ટમ ઉત્પન્ન કરે છે, જેમ કે વેબ સર્વર ડેટા અને સ્ક્રિપ્ટ્સ, FTP સર્વર્સ પર સંગ્રહિત ડેટા અને સિસ્ટમ રીપોઝીટરીઝને નિયંત્રિત કરવા." સંસ્કરણો (FHS માં દેખાય છે. -2.3 2004માં)."

આ બરાબર અમારો કેસ છે, તેથી અમે /srv માં અમને જોઈતી દરેક વસ્તુ મૂકીએ છીએ, જે અમારા એપ્લિકેશન વપરાશકર્તા (ક્લાઉડ-યુઝર) ની માલિકીની છે.

sudo mkdir /srv/djangoapp
sudo chown cloud-user:cloud-user /srv/djangoapp
cd /srv/djangoapp
virtualenv django
source django/bin/activate
pip3 install django gunicorn psycopg2
./django-admin startproject djangoapp /srv/djangoapp

PostgreSQL અને Django સેટ કરવું સરળ છે: ડેટાબેઝ બનાવો, વપરાશકર્તા બનાવો, પરવાનગીઓ ગોઠવો. શરૂઆતમાં PostgreSQL ઇન્સ્ટોલ કરતી વખતે ધ્યાનમાં રાખવાની એક બાબત એ postgresql-setup સ્ક્રિપ્ટ છે જે postgresql-server પેકેજ સાથે ઇન્સ્ટોલ કરેલ છે. આ સ્ક્રિપ્ટ તમને ડેટાબેઝ ક્લસ્ટર એડમિનિસ્ટ્રેશન સાથે સંકળાયેલ મૂળભૂત કાર્યો કરવા માટે મદદ કરે છે, જેમ કે ક્લસ્ટર પ્રારંભ અથવા અપગ્રેડ પ્રક્રિયા. RHEL સિસ્ટમ પર નવા PostgreSQL દાખલાને ગોઠવવા માટે, અમારે આદેશ ચલાવવાની જરૂર છે:

sudo /usr/bin/postgresql-setup -initdb

પછી તમે systemd નો ઉપયોગ કરીને PostgreSQL શરૂ કરી શકો છો, ડેટાબેઝ બનાવી શકો છો અને Django માં પ્રોજેક્ટ સેટ કરી શકો છો. એપ્લિકેશન વપરાશકર્તા માટે પાસવર્ડ સ્ટોરેજ ગોઠવવા માટે ક્લાયંટ પ્રમાણીકરણ રૂપરેખાંકન ફાઇલ (સામાન્ય રીતે pg_hba.conf) માં ફેરફારો કર્યા પછી PostgreSQL ને પુનઃપ્રારંભ કરવાનું યાદ રાખો. જો તમે અન્ય મુશ્કેલીઓનો સામનો કરો છો, તો pg_hba.conf ફાઈલમાં IPv4 અને IPv6 સુયોજનો બદલવાની ખાતરી કરો.

systemctl enable -now postgresql

sudo -u postgres psql
postgres=# create database djangoapp;
postgres=# create user djangouser with password 'qwer4321';
postgres=# alter role djangouser set client_encoding to 'utf8';
postgres=# alter role djangouser set default_transaction_isolation to 'read committed';
postgres=# alter role djangouser set timezone to 'utc';
postgres=# grant all on DATABASE djangoapp to djangouser;
postgres=# q

ફાઇલ /var/lib/pgsql/data/pg_hba.conf માં:

# IPv4 local connections:
host    all        all 0.0.0.0/0                md5
# IPv6 local connections:
host    all        all ::1/128                 md5

ફાઇલ /srv/djangoapp/settings.py માં:

# Database
DATABASES = {
   'default': {
       'ENGINE': 'django.db.backends.postgresql_psycopg2',
       'NAME': '{{ db_name }}',
       'USER': '{{ db_user }}',
       'PASSWORD': '{{ db_password }}',
       'HOST': '{{ db_host }}',
   }
}

પ્રોજેક્ટમાં settings.py ફાઇલને ગોઠવ્યા પછી અને ડેટાબેઝ રૂપરેખાંકન સેટ કર્યા પછી, બધું કામ કરે છે તેની ખાતરી કરવા માટે તમે વિકાસ સર્વર શરૂ કરી શકો છો. ડેવલપમેન્ટ સર્વર શરૂ કર્યા પછી, ડેટાબેઝ સાથે કનેક્શનને ચકાસવા માટે એડમિન વપરાશકર્તા બનાવવાનો સારો વિચાર છે.

./manage.py runserver 0.0.0.0:8000
./manage.py createsuperuser

WSGI? વાઈ?

ડેવલપમેન્ટ સર્વર પરીક્ષણ માટે ઉપયોગી છે, પરંતુ એપ્લિકેશન ચલાવવા માટે તમારે વેબ સર્વર ગેટવે ઈન્ટરફેસ (WSGI) માટે યોગ્ય સર્વર અને પ્રોક્સી ગોઠવવી પડશે. ઘણા સામાન્ય સંયોજનો છે, ઉદાહરણ તરીકે, uWSGI સાથે Apache HTTPD અથવા Gunicorn સાથે Nginx.

વેબ સર્વર ગેટવે ઈન્ટરફેસનું કામ વેબ સર્વરમાંથી વિનંતીઓને પાયથોન વેબ ફ્રેમવર્ક પર ફોરવર્ડ કરવાનું છે. WSGI એ ભયંકર ભૂતકાળનો અવશેષ છે જ્યારે CGI એન્જિન આસપાસ હતા, અને આજે WSGI એ ડી ફેક્ટો સ્ટાન્ડર્ડ છે, વેબ સર્વર અથવા પાયથોન ફ્રેમવર્કનો ઉપયોગ કરવામાં આવ્યો હોય. પરંતુ તેના વ્યાપક ઉપયોગ હોવા છતાં, આ ફ્રેમવર્ક સાથે કામ કરતી વખતે હજુ પણ ઘણી ઘોંઘાટ છે અને ઘણી પસંદગીઓ છે. આ કિસ્સામાં, અમે ગુનિકોર્ન અને Nginx વચ્ચે સોકેટ દ્વારા ક્રિયાપ્રતિક્રિયા સ્થાપિત કરવાનો પ્રયાસ કરીશું.

આ બંને ઘટકો એક જ સર્વર પર ઇન્સ્ટોલ કરેલા હોવાથી, ચાલો નેટવર્ક સોકેટને બદલે યુનિક્સ સોકેટનો ઉપયોગ કરવાનો પ્રયાસ કરીએ. કોઈપણ સંજોગોમાં કોમ્યુનિકેશન માટે સોકેટની આવશ્યકતા હોવાથી, ચાલો એક વધુ પગલું લેવાનો પ્રયાસ કરીએ અને સિસ્ટમડી દ્વારા ગુનિકોર્ન માટે સૉકેટ સક્રિયકરણને ગોઠવીએ.

સોકેટ સક્રિય સેવાઓ બનાવવાની પ્રક્રિયા એકદમ સરળ છે. પ્રથમ, એક યુનિટ ફાઇલ બનાવવામાં આવે છે જેમાં લિસનસ્ટ્રીમ ડાયરેક્ટીવ હોય છે જે બિંદુ પર નિર્દેશ કરે છે કે જ્યાં UNIX સોકેટ બનાવવામાં આવશે, પછી સેવા માટે એક યુનિટ ફાઇલ જેમાં જરૂરી નિર્દેશ સોકેટ યુનિટ ફાઇલ તરફ નિર્દેશ કરશે. પછી, સેવા એકમ ફાઇલમાં, જે બાકી રહે છે તે વર્ચ્યુઅલ પર્યાવરણમાંથી ગુનિકોર્નને કૉલ કરવાનું છે અને UNIX સોકેટ અને Django એપ્લિકેશન માટે WSGI બંધનકર્તા બનાવવાનું છે.

અહીં એકમ ફાઇલોના કેટલાક ઉદાહરણો છે જેનો તમે આધાર તરીકે ઉપયોગ કરી શકો છો. પ્રથમ આપણે સોકેટ સેટ કરીએ છીએ.

[Unit]
Description=Gunicorn WSGI socket

[Socket]
ListenStream=/run/gunicorn.sock

[Install]
WantedBy=sockets.target

હવે તમારે ગુનિકોર્ન ડિમનને ગોઠવવાની જરૂર છે.

[Unit]
Description=Gunicorn daemon
Requires=gunicorn.socket
After=network.target

[Service]
User=cloud-user
Group=cloud-user
WorkingDirectory=/srv/djangoapp

ExecStart=/srv/djangoapp/django/bin/gunicorn 
         —access-logfile - 
         —workers 3 
         —bind unix:gunicorn.sock djangoapp.wsgi

[Install]
WantedBy=multi-user.target

Nginx માટે, પ્રોક્સી રૂપરેખાંકન ફાઇલો બનાવવાની અને જો તમે તેનો ઉપયોગ કરી રહ્યાં હોવ તો સ્થિર સામગ્રીને સંગ્રહિત કરવા માટે ડિરેક્ટરી સેટ કરવી એ એક સરળ બાબત છે. RHEL માં, Nginx રૂપરેખાંકન ફાઇલો /etc/nginx/conf.d માં સ્થિત છે. તમે નીચેના ઉદાહરણને /etc/nginx/conf.d/default.conf ફાઇલમાં કૉપિ કરી શકો છો અને સેવા શરૂ કરી શકો છો. તમારા હોસ્ટના નામ સાથે મેળ કરવા માટે સર્વર_નામ સેટ કરવાની ખાતરી કરો.

server {
   listen 80;
   server_name 8beta1.example.com;

   location = /favicon.ico { access_log off; log_not_found off; }
   location /static/ {
       root /srv/djangoapp;
   }

   location / {
       proxy_set_header Host $http_host;
       proxy_set_header X-Real-IP $remote_addr;
       proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
       proxy_set_header X-Forwarded-Proto $scheme;
       proxy_pass http://unix:/run/gunicorn.sock;
   }
}

Systemd નો ઉપયોગ કરીને Gunicorn સોકેટ અને Nginx શરૂ કરો અને તમે પરીક્ષણ શરૂ કરવા માટે તૈયાર છો.

ખરાબ ગેટવે ભૂલ?

જો તમે તમારા બ્રાઉઝરમાં સરનામું દાખલ કરો છો, તો તમને મોટે ભાગે 502 ખરાબ ગેટવે ભૂલ પ્રાપ્ત થશે. તે ખોટી રીતે રૂપરેખાંકિત UNIX સોકેટ પરવાનગીઓને કારણે થઈ શકે છે, અથવા તે SELinux માં એક્સેસ કંટ્રોલને લગતી વધુ જટિલ સમસ્યાઓને કારણે હોઈ શકે છે.

nginx ભૂલ લોગમાં તમે આના જેવી લાઇન જોઈ શકો છો:

2018/12/18 15:38:03 [crit] 12734#0: *3 connect() to unix:/run/gunicorn.sock failed (13: Permission denied) while connecting to upstream, client: 192.168.122.1, server: 8beta1.example.com, request: "GET / HTTP/1.1", upstream: "http://unix:/run/gunicorn.sock:/", host: "8beta1.example.com"

જો આપણે ગુનિકોર્નનું સીધું પરીક્ષણ કરીશું, તો અમને ખાલી જવાબ મળશે.

curl —unix-socket /run/gunicorn.sock 8beta1.example.com

ચાલો જાણીએ કે આવું શા માટે થાય છે. જો તમે લોગ ખોલો છો, તો તમે મોટે ભાગે જોશો કે સમસ્યા SELinux સાથે સંબંધિત છે. અમે એક ડિમન ચલાવી રહ્યા છીએ જેના માટે કોઈ નીતિ બનાવવામાં આવી નથી, તે init_t તરીકે ચિહ્નિત થયેલ છે. ચાલો આ સિદ્ધાંતને વ્યવહારમાં ચકાસીએ.

sudo setenforce 0

આ બધું ટીકા અને લોહીના આંસુનું કારણ બની શકે છે, પરંતુ આ ફક્ત પ્રોટોટાઇપને ડીબગ કરી રહ્યું છે. ચાલો ફક્ત ખાતરી કરવા માટે કે આ સમસ્યા છે તેની ખાતરી કરવા માટે ચેકને અક્ષમ કરીએ, જેના પછી અમે બધું તેના સ્થાને પાછું આપીશું.

બ્રાઉઝરમાં પૃષ્ઠને તાજું કરીને અથવા અમારા curl આદેશને ફરીથી ચલાવીને, તમે Django પરીક્ષણ પૃષ્ઠ જોઈ શકો છો.

તેથી, બધું કામ કરે છે અને પરવાનગીની કોઈ સમસ્યા નથી તેની ખાતરી કર્યા પછી, અમે SELinux ફરીથી સક્ષમ કરીએ છીએ.

sudo setenforce 1

હું અહીં સેપોલજેન સાથે audit2allow અથવા ચેતવણી-આધારિત નીતિઓ બનાવવા વિશે વાત કરીશ નહીં, કારણ કે આ ક્ષણે ત્યાં કોઈ વાસ્તવિક Django એપ્લિકેશન નથી, તેથી Gunicorn શું ઍક્સેસ કરવા માંગે છે અને તેને શું ઍક્સેસ નકારવી જોઈએ તેનો કોઈ સંપૂર્ણ નકશો નથી. તેથી, સિસ્ટમને સુરક્ષિત રાખવા માટે SELinux ને ચાલુ રાખવું જરૂરી છે, જ્યારે તે જ સમયે એપ્લિકેશનને ચલાવવાની અને ઓડિટ લોગમાં સંદેશાઓ છોડવાની મંજૂરી આપે છે જેથી તેમાંથી વાસ્તવિક નીતિ બનાવી શકાય.

પરવાનગી આપનાર ડોમેન્સનો ઉલ્લેખ કરવો

દરેક વ્યક્તિએ SELinux માં માન્ય ડોમેન્સ વિશે સાંભળ્યું નથી, પરંતુ તે કંઈ નવું નથી. ઘણાએ તો જાણ્યા વિના પણ તેમની સાથે કામ કર્યું. જ્યારે ઓડિટ સંદેશાઓના આધારે નીતિ બનાવવામાં આવે છે, ત્યારે બનાવેલ નીતિ ઉકેલાયેલા ડોમેનને રજૂ કરે છે. ચાલો એક સરળ પરવાનગી નીતિ બનાવવાનો પ્રયાસ કરીએ.

Gunicorn માટે ચોક્કસ મંજૂર ડોમેન બનાવવા માટે, તમારે અમુક પ્રકારની નીતિની જરૂર છે, અને તમારે યોગ્ય ફાઇલોને માર્ક કરવાની પણ જરૂર છે. વધુમાં, નવી નીતિઓ એસેમ્બલ કરવા માટે સાધનોની જરૂર છે.

sudo yum install selinux-policy-devel

મંજૂર ડોમેન્સ મિકેનિઝમ એ સમસ્યાઓને ઓળખવા માટેનું એક શ્રેષ્ઠ સાધન છે, ખાસ કરીને જ્યારે તે કસ્ટમ એપ્લિકેશન અથવા એપ્લિકેશનની વાત આવે છે જે પહેલેથી બનાવેલી નીતિઓ વિના મોકલવામાં આવે છે. આ કિસ્સામાં, Gunicorn માટે મંજૂર ડોમેન નીતિ શક્ય તેટલી સરળ હશે - મુખ્ય પ્રકાર (gunicorn_t) જાહેર કરો, એક પ્રકાર જાહેર કરો જેનો ઉપયોગ અમે બહુવિધ એક્ઝિક્યુટેબલ્સને ચિહ્નિત કરવા માટે કરીશું (gunicorn_exec_t), અને પછી સિસ્ટમને યોગ્ય રીતે ચિહ્નિત કરવા માટે સંક્રમણ સેટ કરો. ચાલી રહેલ પ્રક્રિયાઓ. છેલ્લી લાઇન નીતિને લોડ થાય ત્યારે ડિફોલ્ટ રૂપે સક્ષમ તરીકે સેટ કરે છે.

gunicorn.te:

policy_module(gunicorn, 1.0)

type gunicorn_t;
type gunicorn_exec_t;
init_daemon_domain(gunicorn_t, gunicorn_exec_t)
permissive gunicorn_t;

તમે આ પોલિસી ફાઇલને કમ્પાઇલ કરી શકો છો અને તેને તમારી સિસ્ટમમાં ઉમેરી શકો છો.

make -f /usr/share/selinux/devel/Makefile
sudo semodule -i gunicorn.pp

sudo semanage permissive -a gunicorn_t
sudo semodule -l | grep permissive

ચાલો એ જોવા માટે તપાસ કરીએ કે શું SELinux આપણું અજ્ઞાત ડિમન એક્સેસ કરી રહ્યું છે તે સિવાય બીજું કંઈક બ્લોક કરી રહ્યું છે.

sudo ausearch -m AVC

type=AVC msg=audit(1545315977.237:1273): avc:  denied { write } for pid=19400 comm="nginx" name="gunicorn.sock" dev="tmpfs" ino=52977 scontext=system_u:system_r:httpd_t:s0 tcontext=system_u:object_r:var_run_t:s0 tclass=sock_file permissive=0

SELinux Nginx ને Gunicorn દ્વારા ઉપયોગમાં લેવાતા UNIX સોકેટમાં ડેટા લખવાથી અટકાવે છે. સામાન્ય રીતે, આવા કિસ્સાઓમાં, નીતિઓ બદલવાનું શરૂ થાય છે, પરંતુ આગળ અન્ય પડકારો છે. તમે ડોમેન સેટિંગ્સને પ્રતિબંધ ડોમેનમાંથી પરવાનગી ડોમેનમાં પણ બદલી શકો છો. હવે ચાલો httpd_t ને પરવાનગી ડોમેન પર ખસેડીએ. આ Nginx ને જરૂરી એક્સેસ આપશે અને અમે આગળ ડીબગીંગ કામ ચાલુ રાખી શકીએ છીએ.

sudo semanage permissive -a httpd_t

તેથી, એકવાર તમે SELinux ને સુરક્ષિત રાખવામાં વ્યવસ્થાપિત કરી લો (તમારે ખરેખર SELinux પ્રોજેક્ટને પ્રતિબંધિત મોડમાં છોડવો ન જોઈએ) અને પરવાનગી ડોમેન્સ લોડ થઈ જાય, તો તમારે બધું યોગ્ય રીતે કાર્ય કરવા માટે gunicorn_exec_t તરીકે ચિહ્નિત કરવાની જરૂર છે તે સમજવાની જરૂર છે. ફરી. ચાલો ઍક્સેસ પ્રતિબંધો વિશે નવા સંદેશાઓ જોવા માટે વેબસાઇટની મુલાકાત લેવાનો પ્રયાસ કરીએ.

sudo ausearch -m AVC -c gunicorn

તમે 'comm="gunicorn"' ધરાવતા ઘણા બધા સંદેશાઓ જોશો જે /srv/djangoapp માં ફાઇલો પર વિવિધ વસ્તુઓ કરે છે, તેથી આ સ્પષ્ટપણે ફ્લેગ કરવા યોગ્ય આદેશોમાંથી એક છે.

પરંતુ વધુમાં, આના જેવો સંદેશ દેખાય છે:

type=AVC msg=audit(1545320700.070:1542): avc:  denied { execute } for pid=20704 comm="(gunicorn)" name="python3.6" dev="vda3" ino=8515706 scontext=system_u:system_r:init_t:s0 tcontext=unconfined_u:object_r:var_t:s0 tclass=file permissive=0

જો તમે ગ્યુનિકોર્ન સેવાની સ્થિતિ જોશો અથવા ps કમાન્ડ ચલાવો છો, તો તમે કોઈપણ ચાલી રહેલ પ્રક્રિયાઓ જોશો નહીં. એવું લાગે છે કે ગુનિકોર્ન અમારા વર્ચ્યુઅલેનવ પર્યાવરણમાં પાયથોન દુભાષિયાને ઍક્સેસ કરવાનો પ્રયાસ કરી રહ્યું છે, સંભવતઃ વર્કર સ્ક્રિપ્ટ્સ ચલાવવા માટે. તો હવે ચાલો આ બે એક્ઝિક્યુટેબલ ફાઈલોને માર્ક કરીએ અને તપાસ કરીએ કે શું આપણે આપણું Django ટેસ્ટ પેજ ખોલી શકીએ છીએ.

chcon -t gunicorn_exec_t /srv/djangoapp/django/bin/gunicorn /srv/djangoapp/django/bin/python3.6

નવા ટૅગને પસંદ કરી શકાય તે પહેલાં ગ્યુનિકોર્ન સેવાને ફરીથી શરૂ કરવાની જરૂર પડશે. તમે તેને તરત જ પુનઃપ્રારંભ કરી શકો છો અથવા સેવા બંધ કરી શકો છો અને જ્યારે તમે બ્રાઉઝરમાં સાઇટ ખોલો છો ત્યારે સોકેટને તેને શરૂ કરવા દો. ચકાસો કે પ્રક્રિયાઓએ ps નો ઉપયોગ કરીને યોગ્ય લેબલ્સ પ્રાપ્ત કર્યા છે.

ps -efZ | grep gunicorn

પછીથી સામાન્ય SELinux પોલિસી બનાવવાનું ભૂલશો નહીં!

જો તમે અત્યારે AVC સંદેશાઓ જુઓ છો, તો છેલ્લા સંદેશમાં એપ્લિકેશન સાથે સંબંધિત દરેક વસ્તુ માટે permissive=1 અને બાકીની સિસ્ટમ માટે permissive=0 છે. જો તમે સમજો છો કે વાસ્તવિક એપ્લિકેશનને કયા પ્રકારની ઍક્સેસની જરૂર છે, તો તમે આવી સમસ્યાઓને હલ કરવાનો શ્રેષ્ઠ માર્ગ ઝડપથી શોધી શકો છો. પરંતુ ત્યાં સુધી, સિસ્ટમને સુરક્ષિત રાખવી અને Django પ્રોજેક્ટનું સ્પષ્ટ, ઉપયોગી ઓડિટ મેળવવું શ્રેષ્ઠ છે.

sudo ausearch -m AVC

થયું!

Nginx અને Gunicorn WSGI પર આધારિત ફ્રન્ટએન્ડ સાથે કાર્યરત Django પ્રોજેક્ટ દેખાયો છે. અમે RHEL 3 બીટા રિપોઝીટરીઝમાંથી Python 10 અને PostgreSQL 8 ને ગોઠવ્યું છે. હવે તમે આગળ વધી શકો છો અને Django એપ્લીકેશન બનાવી શકો છો (અથવા ફક્ત જમાવટ કરી શકો છો) અથવા RHEL 8 બીટામાં અન્ય ઉપલબ્ધ ટૂલ્સનું અન્વેષણ કરી શકો છો જેથી ગોઠવણી પ્રક્રિયાને સ્વચાલિત કરી શકાય, કામગીરી બહેતર બનાવી શકાય અથવા આ ગોઠવણીને કન્ટેનરાઇઝ કરી શકાય.

સોર્સ: www.habr.com