ਵਰਕਸ਼ਾਪ RHEL 8 ਬੀਟਾ: ਕੰਮ ਕਰਨ ਵਾਲੇ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਬਣਾਉਣਾ

RHEL 8 ਬੀਟਾ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਬਹੁਤ ਸਾਰੀਆਂ ਨਵੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦਾ ਹੈ, ਜਿਨ੍ਹਾਂ ਦੀ ਸੂਚੀ ਪੰਨੇ ਲੈ ਸਕਦੀ ਹੈ, ਹਾਲਾਂਕਿ, ਨਵੀਆਂ ਚੀਜ਼ਾਂ ਸਿੱਖਣਾ ਹਮੇਸ਼ਾ ਅਭਿਆਸ ਵਿੱਚ ਬਿਹਤਰ ਹੁੰਦਾ ਹੈ, ਇਸ ਲਈ ਹੇਠਾਂ ਅਸੀਂ Red Hat Enterprise Linux 8 ਬੀਟਾ 'ਤੇ ਅਧਾਰਤ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਬੁਨਿਆਦੀ ਢਾਂਚਾ ਬਣਾਉਣ ਲਈ ਇੱਕ ਵਰਕਸ਼ਾਪ ਪੇਸ਼ ਕਰਦੇ ਹਾਂ।

ਚਲੋ ਪਾਇਥਨ, ਡਿਵੈਲਪਰਾਂ ਵਿੱਚ ਇੱਕ ਪ੍ਰਸਿੱਧ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾ ਨੂੰ ਇੱਕ ਅਧਾਰ ਦੇ ਤੌਰ ਤੇ, Django ਅਤੇ PostgreSQL ਦਾ ਸੁਮੇਲ, ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣ ਲਈ ਇੱਕ ਕਾਫ਼ੀ ਆਮ ਸੁਮੇਲ, ਅਤੇ ਉਹਨਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ RHEL 8 ਬੀਟਾ ਨੂੰ ਸੰਰਚਿਤ ਕਰੀਏ। ਫਿਰ ਅਸੀਂ ਕੁਝ ਹੋਰ (ਅਵਰਗੀਕ੍ਰਿਤ) ਸਮੱਗਰੀ ਸ਼ਾਮਲ ਕਰਾਂਗੇ।

ਟੈਸਟ ਵਾਤਾਵਰਣ ਬਦਲ ਜਾਵੇਗਾ, ਕਿਉਂਕਿ ਇਹ ਆਟੋਮੇਸ਼ਨ ਦੀਆਂ ਸੰਭਾਵਨਾਵਾਂ ਦੀ ਪੜਚੋਲ ਕਰਨਾ, ਕੰਟੇਨਰਾਂ ਨਾਲ ਕੰਮ ਕਰਨਾ ਅਤੇ ਮਲਟੀਪਲ ਸਰਵਰਾਂ ਨਾਲ ਵਾਤਾਵਰਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨਾ ਦਿਲਚਸਪ ਹੈ। ਇੱਕ ਨਵੇਂ ਪ੍ਰੋਜੈਕਟ ਨਾਲ ਸ਼ੁਰੂਆਤ ਕਰਨ ਲਈ, ਤੁਸੀਂ ਹੱਥਾਂ ਨਾਲ ਇੱਕ ਛੋਟਾ, ਸਧਾਰਨ ਪ੍ਰੋਟੋਟਾਈਪ ਬਣਾ ਕੇ ਸ਼ੁਰੂਆਤ ਕਰ ਸਕਦੇ ਹੋ ਤਾਂ ਜੋ ਤੁਸੀਂ ਇਹ ਦੇਖ ਸਕੋ ਕਿ ਕੀ ਹੋਣ ਦੀ ਲੋੜ ਹੈ ਅਤੇ ਇਹ ਕਿਵੇਂ ਇੰਟਰੈਕਟ ਕਰਦਾ ਹੈ, ਅਤੇ ਫਿਰ ਸਵੈਚਲਿਤ ਅਤੇ ਹੋਰ ਗੁੰਝਲਦਾਰ ਸੰਰਚਨਾਵਾਂ ਬਣਾਉਣ ਲਈ ਅੱਗੇ ਵਧੋ। ਅੱਜ ਅਸੀਂ ਅਜਿਹੇ ਪ੍ਰੋਟੋਟਾਈਪ ਬਣਾਉਣ ਬਾਰੇ ਗੱਲ ਕਰ ਰਹੇ ਹਾਂ।

ਆਉ RHEL 8 ਬੀਟਾ VM ਚਿੱਤਰ ਨੂੰ ਤੈਨਾਤ ਕਰਕੇ ਸ਼ੁਰੂ ਕਰੀਏ। ਤੁਸੀਂ ਸਕ੍ਰੈਚ ਤੋਂ ਇੱਕ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਇੰਸਟਾਲ ਕਰ ਸਕਦੇ ਹੋ, ਜਾਂ ਆਪਣੀ ਬੀਟਾ ਗਾਹਕੀ ਨਾਲ ਉਪਲਬਧ 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 ਆਪਣੇ ਆਪ ਵਿੱਚ ਸਰਗਰਮ ਵਿਕਾਸ ਅਧੀਨ ਹੈ, ਅਤੇ ਵੱਧ ਤੋਂ ਵੱਧ ਨਵੇਂ ਸੰਸਕਰਣ ਲਗਾਤਾਰ ਦਿਖਾਈ ਦੇ ਰਹੇ ਹਨ। ਇਸ ਲਈ, ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਪਾਈਥਨ ਦੇ ਵੱਖ-ਵੱਖ ਨਵੇਂ ਸੰਸਕਰਣਾਂ ਤੱਕ ਪਹੁੰਚ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹੋਏ ਸਥਿਰ ਸਿਸਟਮ ਟੂਲਸ ਦੀ ਲੋੜ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ, ਸਿਸਟਮ ਪਾਈਥਨ ਨੂੰ ਇੱਕ ਨਵੇਂ ਪੈਕੇਜ ਵਿੱਚ ਤਬਦੀਲ ਕੀਤਾ ਗਿਆ ਸੀ ਅਤੇ ਪਾਈਥਨ 2.7 ਅਤੇ 3.6 ਦੋਵਾਂ ਨੂੰ ਇੰਸਟਾਲ ਕਰਨ ਦੀ ਯੋਗਤਾ ਪ੍ਰਦਾਨ ਕੀਤੀ ਗਈ ਸੀ। ਤਬਦੀਲੀਆਂ ਅਤੇ ਉਹ ਕਿਉਂ ਕੀਤੀਆਂ ਗਈਆਂ ਸਨ, ਇਸ ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਵਿੱਚ ਪ੍ਰਕਾਸ਼ਨ ਵਿੱਚ ਲੱਭੀ ਜਾ ਸਕਦੀ ਹੈ ਲੈਂਗਡਨ ਵ੍ਹਾਈਟ ਦਾ ਬਲੌਗ (ਲੈਂਗਡਨ ਵ੍ਹਾਈਟ)।

ਇਸ ਲਈ, ਕੰਮ ਕਰਨ ਵਾਲੇ ਪਾਈਥਨ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਦੋ ਪੈਕੇਜ ਸਥਾਪਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਜਿਸ ਵਿੱਚ python3-pip ਇੱਕ ਨਿਰਭਰਤਾ ਵਜੋਂ ਸ਼ਾਮਲ ਹੈ।

sudo yum install python36 python3-virtualenv

ਕਿਉਂ ਨਾ ਸਿੱਧੇ ਮੋਡੀਊਲ ਕਾਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਿਵੇਂ ਕਿ ਲੈਂਗਡਨ ਨੇ ਸੁਝਾਅ ਦਿੱਤਾ ਹੈ ਅਤੇ ਪਾਈਪ3 ਨੂੰ ਸਥਾਪਿਤ ਕਰੋ? ਆਗਾਮੀ ਆਟੋਮੇਸ਼ਨ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੇ ਹੋਏ, ਇਹ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ ਕਿ Ansible ਨੂੰ ਚੱਲਣ ਲਈ ਪਾਈਪ ਇੰਸਟਾਲ ਕਰਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ, ਕਿਉਂਕਿ ਪਾਈਪ ਮੋਡੀਊਲ ਇੱਕ ਕਸਟਮ ਪਾਈਪ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਨਾਲ ਵਰਚੁਅਲੇਨਵ ਦਾ ਸਮਰਥਨ ਨਹੀਂ ਕਰਦਾ ਹੈ।

ਤੁਹਾਡੇ ਨਿਪਟਾਰੇ 'ਤੇ ਕੰਮ ਕਰਨ ਵਾਲੇ python3 ਦੁਭਾਸ਼ੀਏ ਦੇ ਨਾਲ, ਤੁਸੀਂ Django ਇੰਸਟਾਲੇਸ਼ਨ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਜਾਰੀ ਰੱਖ ਸਕਦੇ ਹੋ ਅਤੇ ਸਾਡੇ ਦੂਜੇ ਭਾਗਾਂ ਦੇ ਨਾਲ ਇੱਕ ਕਾਰਜ ਪ੍ਰਣਾਲੀ ਵੀ ਰੱਖ ਸਕਦੇ ਹੋ। ਇੰਟਰਨੈੱਟ 'ਤੇ ਬਹੁਤ ਸਾਰੇ ਲਾਗੂ ਕਰਨ ਦੇ ਵਿਕਲਪ ਉਪਲਬਧ ਹਨ। ਇੱਥੇ ਇੱਕ ਸੰਸਕਰਣ ਪੇਸ਼ ਕੀਤਾ ਗਿਆ ਹੈ, ਪਰ ਉਪਭੋਗਤਾ ਆਪਣੀਆਂ ਖੁਦ ਦੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਨ।

ਅਸੀਂ ਯੂਮ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਡਿਫੌਲਟ ਰੂਪ ਵਿੱਚ RHEL 8 ਵਿੱਚ ਉਪਲਬਧ PostgreSQL ਅਤੇ Nginx ਸੰਸਕਰਣਾਂ ਨੂੰ ਸਥਾਪਿਤ ਕਰਾਂਗੇ।

sudo yum install nginx postgresql-server

PostgreSQL ਨੂੰ psycopg2 ਦੀ ਲੋੜ ਹੋਵੇਗੀ, ਪਰ ਇਹ ਕੇਵਲ ਇੱਕ ਵਰਚੁਅਲੇਨਵ ਵਾਤਾਵਰਨ ਵਿੱਚ ਉਪਲਬਧ ਹੋਣ ਦੀ ਲੋੜ ਹੈ, ਇਸਲਈ ਅਸੀਂ ਇਸਨੂੰ Django ਅਤੇ Gunicorn ਦੇ ਨਾਲ pip3 ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੰਸਟਾਲ ਕਰਾਂਗੇ। ਪਰ ਪਹਿਲਾਂ ਸਾਨੂੰ virtualenv ਸੈਟ ਅਪ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।

Django ਪ੍ਰੋਜੈਕਟਾਂ ਨੂੰ ਸਥਾਪਤ ਕਰਨ ਲਈ ਸਹੀ ਜਗ੍ਹਾ ਦੀ ਚੋਣ ਕਰਨ ਦੇ ਵਿਸ਼ੇ 'ਤੇ ਹਮੇਸ਼ਾਂ ਬਹੁਤ ਬਹਿਸ ਹੁੰਦੀ ਹੈ, ਪਰ ਜਦੋਂ ਸ਼ੱਕ ਹੋਵੇ, ਤਾਂ ਤੁਸੀਂ ਹਮੇਸ਼ਾਂ ਲੀਨਕਸ ਫਾਈਲਸਿਸਟਮ ਲੜੀਵਾਰ ਸਟੈਂਡਰਡ ਵੱਲ ਮੁੜ ਸਕਦੇ ਹੋ। ਖਾਸ ਤੌਰ 'ਤੇ, FHS ਕਹਿੰਦਾ ਹੈ ਕਿ /srv ਦੀ ਵਰਤੋਂ ਇਸ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ: "ਹੋਸਟ-ਵਿਸ਼ੇਸ਼ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ—ਸਿਸਟਮ ਦੁਆਰਾ ਪੈਦਾ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਡੇਟਾ, ਜਿਵੇਂ ਕਿ ਵੈੱਬ ਸਰਵਰ ਡੇਟਾ ਅਤੇ ਸਕ੍ਰਿਪਟਾਂ, 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 ਨਾਲ ਅਪਾਚੇ HTTPD ਜਾਂ Gunicorn ਦੇ ਨਾਲ Nginx।

ਵੈੱਬ ਸਰਵਰ ਗੇਟਵੇ ਇੰਟਰਫੇਸ ਦਾ ਕੰਮ ਵੈਬ ਸਰਵਰ ਤੋਂ ਪਾਈਥਨ ਵੈੱਬ ਫਰੇਮਵਰਕ ਲਈ ਬੇਨਤੀਆਂ ਨੂੰ ਅੱਗੇ ਭੇਜਣਾ ਹੈ। WSGI ਭਿਆਨਕ ਅਤੀਤ ਦੀ ਇੱਕ ਯਾਦ ਹੈ ਜਦੋਂ CGI ਇੰਜਣ ਆਲੇ-ਦੁਆਲੇ ਸਨ, ਅਤੇ ਅੱਜ WSGI ਅਸਲ ਮਿਆਰੀ ਹੈ, ਵੈੱਬ ਸਰਵਰ ਜਾਂ ਪਾਈਥਨ ਫਰੇਮਵਰਕ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ। ਪਰ ਇਸਦੀ ਵਿਆਪਕ ਵਰਤੋਂ ਦੇ ਬਾਵਜੂਦ, ਇਹਨਾਂ ਫਰੇਮਵਰਕ ਦੇ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਅਜੇ ਵੀ ਬਹੁਤ ਸਾਰੀਆਂ ਸੂਖਮਤਾਵਾਂ ਅਤੇ ਬਹੁਤ ਸਾਰੀਆਂ ਚੋਣਾਂ ਹਨ. ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਸਾਕਟ ਦੁਆਰਾ ਗੁਨੀਕੋਰਨ ਅਤੇ ਐਨਜੀਨੈਕਸ ਵਿਚਕਾਰ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਸਥਾਪਤ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਾਂਗੇ।

ਕਿਉਂਕਿ ਇਹ ਦੋਵੇਂ ਭਾਗ ਇੱਕੋ ਸਰਵਰ 'ਤੇ ਸਥਾਪਿਤ ਕੀਤੇ ਗਏ ਹਨ, ਆਓ ਇੱਕ ਨੈੱਟਵਰਕ ਸਾਕਟ ਦੀ ਬਜਾਏ ਇੱਕ UNIX ਸਾਕਟ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ। ਕਿਉਂਕਿ ਸੰਚਾਰ ਲਈ ਕਿਸੇ ਵੀ ਸਥਿਤੀ ਵਿੱਚ ਇੱਕ ਸਾਕਟ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਆਓ ਇੱਕ ਹੋਰ ਕਦਮ ਚੁੱਕਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ ਅਤੇ ਸਿਸਟਮਡ ਦੁਆਰਾ ਗੁਨੀਕੋਰਨ ਲਈ ਸਾਕਟ ਐਕਟੀਵੇਸ਼ਨ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰੀਏ।

ਸਾਕਟ ਐਕਟੀਵੇਟਿਡ ਸੇਵਾਵਾਂ ਬਣਾਉਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਾਫ਼ੀ ਸਧਾਰਨ ਹੈ. ਪਹਿਲਾਂ, ਇੱਕ ਯੂਨਿਟ ਫਾਈਲ ਬਣਾਈ ਜਾਂਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਇੱਕ ListenStream ਡਾਇਰੈਕਟਿਵ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ ਜੋ ਉਸ ਬਿੰਦੂ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦਾ ਹੈ ਜਿਸ 'ਤੇ 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;
   }
}

ਸਿਸਟਮਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਗੁਨੀਕੋਰਨ ਸਾਕਟ ਅਤੇ ਐਨਜੀਨੈਕਸ ਸ਼ੁਰੂ ਕਰੋ ਅਤੇ ਤੁਸੀਂ ਜਾਂਚ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਤਿਆਰ ਹੋ।

ਗਲਤ ਗੇਟਵੇ ਗਲਤੀ?

ਜੇਕਰ ਤੁਸੀਂ ਆਪਣੇ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਪਤਾ ਦਰਜ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਸੰਭਾਵਤ ਤੌਰ 'ਤੇ 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

ਮੈਂ ਇੱਥੇ sepolgen ਨਾਲ audit2allow ਜਾਂ ਚੇਤਾਵਨੀ-ਅਧਾਰਿਤ ਨੀਤੀਆਂ ਬਣਾਉਣ ਬਾਰੇ ਗੱਲ ਨਹੀਂ ਕਰਾਂਗਾ, ਕਿਉਂਕਿ ਇਸ ਸਮੇਂ ਕੋਈ ਅਸਲ Django ਐਪਲੀਕੇਸ਼ਨ ਨਹੀਂ ਹੈ, ਇਸ ਲਈ ਇੱਥੇ ਕੋਈ ਪੂਰਾ ਨਕਸ਼ਾ ਨਹੀਂ ਹੈ ਕਿ ਗੁਨੀਕੋਰਨ ਕਿਸ ਤੱਕ ਪਹੁੰਚ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਕਿਸ ਤੱਕ ਪਹੁੰਚ ਤੋਂ ਇਨਕਾਰ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਇਸ ਲਈ, ਸਿਸਟਮ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਣ ਲਈ 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 ਨੂੰ ਕੌਂਫਿਗਰ ਕੀਤਾ ਹੈ। ਹੁਣ ਤੁਸੀਂ ਸੰਰਚਨਾ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਵੈਚਲਿਤ ਕਰਨ, ਕਾਰਗੁਜ਼ਾਰੀ ਵਿੱਚ ਸੁਧਾਰ ਕਰਨ, ਜਾਂ ਇਸ ਸੰਰਚਨਾ ਨੂੰ ਕੰਟੇਨਰਾਈਜ਼ ਕਰਨ ਲਈ RHEL 8 ਬੀਟਾ ਵਿੱਚ ਹੋਰ ਉਪਲਬਧ ਸਾਧਨਾਂ ਦੀ ਪੜਚੋਲ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ Django ਐਪਲੀਕੇਸ਼ਨ ਬਣਾ ਸਕਦੇ ਹੋ ਅਤੇ ਬਣਾ ਸਕਦੇ ਹੋ।

ਸਰੋਤ: www.habr.com