RHEL 8 பீட்டா டெவலப்பர்களுக்கு பல புதிய அம்சங்களை வழங்குகிறது, அவற்றின் பட்டியலானது பக்கங்களை எடுக்கலாம், இருப்பினும், புதிய விஷயங்களைக் கற்றுக்கொள்வது நடைமுறையில் எப்போதும் சிறப்பாக இருக்கும், எனவே Red Hat Enterprise Linux 8 பீட்டாவின் அடிப்படையில் ஒரு பயன்பாட்டு உள்கட்டமைப்பை உண்மையில் உருவாக்குவதற்கான ஒரு பட்டறையை கீழே வழங்குகிறோம்.
டெவலப்பர்களிடையே பிரபலமான நிரலாக்க மொழியான Python ஐ அடிப்படையாக எடுத்துக்கொள்வோம், இது Django மற்றும் PostgreSQL ஆகியவற்றின் கலவையாகும். பின்னர் இன்னும் இரண்டு (வகைப்படுத்தப்படாத) பொருட்களைச் சேர்ப்போம்.
சோதனை சூழல் மாறும், ஏனெனில் ஆட்டோமேஷனின் சாத்தியக்கூறுகளை ஆராய்வது, கொள்கலன்களுடன் பணிபுரிவது மற்றும் பல சேவையகங்களுடன் சூழல்களை முயற்சிப்பது சுவாரஸ்யமானது. ஒரு புதிய திட்டத்துடன் தொடங்குவதற்கு, நீங்கள் ஒரு சிறிய, எளிய முன்மாதிரியை கைமுறையாக உருவாக்குவதன் மூலம் தொடங்கலாம், இதன் மூலம் நீங்கள் சரியாக என்ன நடக்க வேண்டும் மற்றும் அது எவ்வாறு தொடர்பு கொள்கிறது என்பதைக் காணலாம், பின்னர் தானியங்கு மற்றும் சிக்கலான உள்ளமைவுகளை உருவாக்கவும். இன்று நாம் அத்தகைய முன்மாதிரியை உருவாக்குவது பற்றி பேசுகிறோம்.
RHEL 8 பீட்டா VM படத்தைப் பயன்படுத்துவதன் மூலம் தொடங்குவோம். நீங்கள் புதிதாக ஒரு மெய்நிகர் இயந்திரத்தை நிறுவலாம் அல்லது உங்கள் பீட்டா சந்தாவுடன் கிடைக்கும் KVM விருந்தினர் படத்தைப் பயன்படுத்தலாம். விருந்தினர் படத்தைப் பயன்படுத்தும் போது, கிளவுட் துவக்கத்திற்கான (Cloud-init) மெட்டாடேட்டா மற்றும் பயனர் தரவைக் கொண்டிருக்கும் மெய்நிகர் சிடியை நீங்கள் கட்டமைக்க வேண்டும். வட்டு அமைப்பு அல்லது கிடைக்கக்கூடிய தொகுப்புகளுடன் நீங்கள் சிறப்பு எதுவும் செய்ய வேண்டியதில்லை; எந்த உள்ளமைவும் செய்யும்.
முழு செயல்முறையையும் விரிவாகப் பார்ப்போம்.
ஜாங்கோவை நிறுவுகிறது
ஜாங்கோவின் புதிய பதிப்பில், பைதான் 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 Python ஐ RHEL இல் கணினி கருவித்தொகுப்பாக தீவிரமாகப் பயன்படுத்துகிறது, எனவே இது ஏன் விளைகிறது?
உண்மை என்னவென்றால், பல பைதான் டெவலப்பர்கள் இன்னும் பைதான் 2 இலிருந்து பைதான் 2 க்கு மாறுவதைப் பற்றி சிந்திக்கிறார்கள், அதே நேரத்தில் பைதான் 3 தானே செயலில் வளர்ச்சியில் உள்ளது, மேலும் மேலும் மேலும் புதிய பதிப்புகள் தொடர்ந்து தோன்றும். எனவே, பைத்தானின் பல்வேறு புதிய பதிப்புகளுக்கான அணுகலை பயனர்களுக்கு வழங்கும் போது நிலையான கணினி கருவிகளின் தேவையை பூர்த்தி செய்ய, கணினி பைதான் ஒரு புதிய தொகுப்பிற்கு மாற்றப்பட்டது மற்றும் பைதான் 2.7 மற்றும் 3.6 இரண்டையும் நிறுவும் திறனை வழங்கியது. மாற்றங்கள் மற்றும் அவை ஏன் செய்யப்பட்டன என்பது பற்றிய கூடுதல் தகவல்களை இன் வெளியீட்டில் காணலாம் (லாங்டன் ஒயிட்).
எனவே, வேலை செய்யும் பைத்தானைப் பெற, நீங்கள் இரண்டு தொகுப்புகளை நிறுவ வேண்டும், python3-pip ஒரு சார்புநிலையாக சேர்க்கப்பட்டுள்ளது.
sudo yum install python36 python3-virtualenv
லாங்டன் பரிந்துரைத்தபடி நேரடி தொகுதி அழைப்புகளை ஏன் பயன்படுத்தக்கூடாது மற்றும் pip3 ஐ நிறுவ வேண்டும்? வரவிருக்கும் ஆட்டோமேஷனை மனதில் வைத்து, அன்சிபிள் இயக்குவதற்கு பிப் நிறுவப்பட வேண்டும் என்று அறியப்படுகிறது, ஏனெனில் பிப் தொகுதி இயங்கக்கூடிய தனிப்பயன் பிப் இயங்கக்கூடிய விர்ச்சுவலென்விஸை ஆதரிக்காது.
உங்கள் வசம் ஒரு வேலை செய்யும் python3 மொழிபெயர்ப்பாளருடன், நீங்கள் ஜாங்கோ நிறுவல் செயல்முறையைத் தொடரலாம் மற்றும் எங்கள் பிற கூறுகளுடன் இணைந்து செயல்படும் அமைப்பைப் பெறலாம். இணையத்தில் பல செயல்படுத்தல் விருப்பங்கள் உள்ளன. இங்கே ஒரு பதிப்பு உள்ளது, ஆனால் பயனர்கள் தங்கள் சொந்த செயல்முறைகளைப் பயன்படுத்தலாம்.
Yum ஐப் பயன்படுத்தி இயல்பாக RHEL 8 இல் கிடைக்கும் PostgreSQL மற்றும் Nginx பதிப்புகளை நிறுவுவோம்.
sudo yum install nginx postgresql-server
PostgreSQL க்கு psycopg2 தேவைப்படும், ஆனால் அது ஒரு virtualenv சூழலில் மட்டுமே கிடைக்க வேண்டும், எனவே Django மற்றும் Gunicorn உடன் pip3 ஐப் பயன்படுத்தி நிறுவுவோம். ஆனால் முதலில் நாம் virtualenv ஐ அமைக்க வேண்டும்.
ஜாங்கோ ப்ராஜெக்ட்களை நிறுவ சரியான இடத்தைத் தேர்ந்தெடுப்பது என்ற தலைப்பில் எப்போதும் நிறைய விவாதங்கள் உள்ளன, ஆனால் சந்தேகம் இருந்தால், நீங்கள் எப்போதும் Linux Filesystem Hierarchy Standard க்கு திரும்பலாம். குறிப்பாக, FHS கூறுகிறது: "புரவலன்-குறிப்பிட்ட தரவைச் சேமித்து வைப்பதற்குப் பயன்படுகிறது—வலை சேவையகத் தரவு மற்றும் ஸ்கிரிப்டுகள், 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-server தொகுப்புடன் நிறுவப்பட்ட postgresql-அமைவு ஸ்கிரிப்ட் ஆகும். இந்த ஸ்கிரிப்ட், தரவுத்தள கிளஸ்டர் நிர்வாகத்துடன் தொடர்புடைய அடிப்படைப் பணிகளைச் செய்ய உதவுகிறது, அதாவது கிளஸ்டர் துவக்கம் அல்லது மேம்படுத்தல் செயல்முறை. ஒரு RHEL கணினியில் ஒரு புதிய PostgreSQL நிகழ்வை உள்ளமைக்க, நாம் கட்டளையை இயக்க வேண்டும்:
sudo /usr/bin/postgresql-setup -initdb
நீங்கள் Systemd ஐப் பயன்படுத்தி PostgreSQL ஐத் தொடங்கலாம், தரவுத்தளத்தை உருவாக்கலாம் மற்றும் ஜாங்கோவில் ஒரு திட்டத்தை அமைக்கலாம். பயன்பாட்டு பயனருக்கான கடவுச்சொல் சேமிப்பகத்தை உள்ளமைக்க, கிளையன்ட் அங்கீகரிப்பு உள்ளமைவு கோப்பில் (பொதுவாக 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 என்பது இணைய சேவையகம் அல்லது பைதான் கட்டமைப்பைப் பொருட்படுத்தாமல் நடைமுறை தரநிலையாக உள்ளது. ஆனால் அதன் பரவலான பயன்பாடு இருந்தபோதிலும், இந்த கட்டமைப்புகளுடன் பணிபுரியும் போது இன்னும் பல நுணுக்கங்கள் உள்ளன, மேலும் பல தேர்வுகள் உள்ளன. இந்த வழக்கில், Gunicorn மற்றும் Nginx இடையே ஒரு சாக்கெட் வழியாக தொடர்புகளை ஏற்படுத்த முயற்சிப்போம்.
இந்த இரண்டு கூறுகளும் ஒரே சர்வரில் நிறுவப்பட்டிருப்பதால், நெட்வொர்க் சாக்கெட்டுக்குப் பதிலாக யுனிக்ஸ் சாக்கெட்டைப் பயன்படுத்த முயற்சிப்போம். எந்தவொரு சந்தர்ப்பத்திலும் தகவல்தொடர்புக்கு ஒரு சாக்கெட் தேவைப்படுவதால், இன்னும் ஒரு படி எடுத்து, systemd வழியாக Gunicorn க்கான சாக்கெட் செயல்படுத்தலை உள்ளமைக்க முயற்சிப்போம்.
சாக்கெட் செயல்படுத்தப்பட்ட சேவைகளை உருவாக்கும் செயல்முறை மிகவும் எளிது. முதலில், UNIX சாக்கெட் உருவாக்கப்படும் புள்ளியை சுட்டிக்காட்டும் ListenStream கட்டளையை உள்ளடக்கிய ஒரு யூனிட் கோப்பு உருவாக்கப்படுகிறது, பின்னர் சேவைக்கான ஒரு யூனிட் கோப்பு, அதில் தேவைப்படும் உத்தரவு சாக்கெட் யூனிட் கோப்பை சுட்டிக்காட்டும். பின்னர், சேவை அலகு கோப்பில், மெய்நிகர் சூழலில் இருந்து Gunicorn ஐ அழைப்பது மற்றும் UNIX சாக்கெட் மற்றும் ஜாங்கோ பயன்பாட்டிற்கான WSGI பிணைப்பை உருவாக்குவது மட்டுமே மீதமுள்ளது.
நீங்கள் அடிப்படையாகப் பயன்படுத்தக்கூடிய யூனிட் கோப்புகளின் சில எடுத்துக்காட்டுகள் இங்கே உள்ளன. முதலில் நாம் சாக்கெட்டை அமைக்கிறோம்.
[Unit]
Description=Gunicorn WSGI socket
[Socket]
ListenStream=/run/gunicorn.sock
[Install]
WantedBy=sockets.target
இப்போது நீங்கள் Gunicorn deemon ஐ கட்டமைக்க வேண்டும்.
[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
இவை அனைத்தும் விமர்சனத்தையும் இரத்தக் கண்ணீரையும் ஏற்படுத்தக்கூடும், ஆனால் இது முன்மாதிரியை பிழைத்திருத்துகிறது. இது தான் பிரச்சனை என்பதை உறுதிப்படுத்த காசோலையை முடக்குவோம், அதன் பிறகு எல்லாவற்றையும் அதன் இடத்திற்குத் திருப்பி விடுவோம்.
உலாவியில் பக்கத்தைப் புதுப்பிப்பதன் மூலம் அல்லது எங்கள் கர்ல் கட்டளையை மீண்டும் இயக்குவதன் மூலம், நீங்கள் ஜாங்கோ சோதனைப் பக்கத்தைப் பார்க்கலாம்.
எனவே, அனைத்தும் செயல்படுவதை உறுதிசெய்து, மேலும் அனுமதிச் சிக்கல்கள் எதுவும் இல்லை, நாங்கள் மீண்டும் SELinux ஐ இயக்குகிறோம்.
sudo setenforce 1
audit2allow அல்லது sepolgen உடன் விழிப்பூட்டல் அடிப்படையிலான கொள்கைகளை உருவாக்குவது பற்றி நான் இங்கு பேசமாட்டேன், ஏனெனில் தற்சமயம் 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
Gunicorn பயன்படுத்தும் UNIX சாக்கெட்டில் தரவை எழுதுவதிலிருந்து Nginx ஐ SELinux தடுக்கிறது. பொதுவாக, இதுபோன்ற சந்தர்ப்பங்களில், கொள்கைகள் மாறத் தொடங்குகின்றன, ஆனால் வேறு சவால்கள் உள்ளன. நீங்கள் டொமைன் அமைப்புகளை கட்டுப்பாட்டு டொமைனில் இருந்து அனுமதி டொமைனாக மாற்றலாம். இப்போது httpd_tஐ அனுமதி டொமைனுக்கு நகர்த்துவோம். இது Nginxக்கு தேவையான அணுகலை வழங்கும், மேலும் பிழைத்திருத்த வேலைகளை நாம் தொடரலாம்.
sudo semanage permissive -a httpd_t
எனவே, நீங்கள் SELinux ஐப் பாதுகாக்க முடிந்தவுடன் (நீங்கள் SELinux திட்டத்தை தடைசெய்யப்பட்ட பயன்முறையில் விட்டுவிடக் கூடாது) மற்றும் அனுமதி டொமைன்கள் ஏற்றப்பட்டவுடன், எல்லாவற்றையும் சரியாகச் செயல்படுவதற்கு gunicorn_exec_t எனக் குறிக்கப்பட வேண்டியதை நீங்கள் கண்டுபிடிக்க வேண்டும். மீண்டும். அணுகல் கட்டுப்பாடுகள் பற்றிய புதிய செய்திகளைப் பார்க்க இணையதளத்தைப் பார்வையிட முயற்சிப்போம்.
sudo ausearch -m AVC -c gunicorn
/srv/djangoapp இல் உள்ள கோப்புகளில் பல்வேறு விஷயங்களைச் செய்யும் 'comm="gunicorn"' ஐக் கொண்ட பல செய்திகளை நீங்கள் காண்பீர்கள், எனவே இது வெளிப்படையாகக் கொடியிட வேண்டிய கட்டளைகளில் ஒன்றாகும்.
ஆனால் கூடுதலாக, இது போன்ற ஒரு செய்தி தோன்றும்:
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 கட்டளையை இயக்கினால், எந்த இயங்கும் செயல்முறைகளையும் நீங்கள் காண முடியாது. Gunicorn எங்கள் virtualenv சூழலில் பைதான் மொழிபெயர்ப்பாளரை அணுக முயற்சிப்பது போல் தெரிகிறது, ஒருவேளை வேலை செய்பவர் ஸ்கிரிப்ட்களை இயக்கலாம். எனவே இப்போது இந்த இரண்டு இயங்கக்கூடிய கோப்புகளைக் குறிப்போம் மற்றும் எங்கள் ஜாங்கோ சோதனைப் பக்கத்தைத் திறக்க முடியுமா என்று பார்க்கலாம்.
chcon -t gunicorn_exec_t /srv/djangoapp/django/bin/gunicorn /srv/djangoapp/django/bin/python3.6
புதிய குறிச்சொல்லைத் தேர்ந்தெடுக்கும் முன் குனிகார்ன் சேவையை மறுதொடக்கம் செய்ய வேண்டும். நீங்கள் அதை உடனடியாக மறுதொடக்கம் செய்யலாம் அல்லது சேவையை நிறுத்தலாம் மற்றும் உலாவியில் தளத்தைத் திறக்கும்போது சாக்கெட் அதைத் தொடங்கலாம். ps ஐப் பயன்படுத்தி செயல்முறைகள் சரியான லேபிள்களைப் பெற்றுள்ளதா என்பதைச் சரிபார்க்கவும்.
ps -efZ | grep gunicorn
பின்னர் ஒரு சாதாரண SELinux கொள்கையை உருவாக்க மறக்காதீர்கள்!
நீங்கள் இப்போது AVC செய்திகளைப் பார்த்தால், கடைசி செய்தியில் பயன்பாடு தொடர்பான அனைத்திற்கும் அனுமதி = 1 மற்றும் மீதமுள்ள கணினிக்கு அனுமதி = 0 உள்ளது. உண்மையான பயன்பாட்டிற்கு என்ன வகையான அணுகல் தேவை என்பதை நீங்கள் புரிந்து கொண்டால், இதுபோன்ற சிக்கல்களைத் தீர்ப்பதற்கான சிறந்த வழியை விரைவாகக் கண்டறியலாம். ஆனால் அதுவரை, கணினியைப் பாதுகாப்பாக வைத்திருப்பது மற்றும் ஜாங்கோ திட்டத்தின் தெளிவான, பயன்படுத்தக்கூடிய தணிக்கையைப் பெறுவது சிறந்தது.
sudo ausearch -m AVC
நடந்தது!
Nginx மற்றும் Gunicorn WSGI ஐ அடிப்படையாகக் கொண்ட முன்னோடியுடன் செயல்படும் ஜாங்கோ திட்டம் தோன்றியது. RHEL 3 பீட்டா களஞ்சியங்களில் இருந்து Python 10 மற்றும் PostgreSQL 8 ஐ உள்ளமைத்தோம். இப்போது நீங்கள் முன்னோக்கி நகர்த்தலாம் மற்றும் Django பயன்பாடுகளை உருவாக்கலாம் (அல்லது வரிசைப்படுத்தலாம்) அல்லது RHEL 8 பீட்டாவில் உள்ள மற்ற கருவிகளை ஆராயலாம்
ஆதாரம்: www.habr.com