A Chef-solo használata a Django alkalmazás konfigurálásához Ubuntun

A dobozok beállításának és konfigurálásának folyamatát számos módon automatizálhatjuk. Bármilyen okból kifolyólag, ha az egész rendszerünk jelenleg csak egyetlen dobozból áll, a teljes SCM (Software Configuration Management) infrastruktúra létrehozása túlzás. A shell szkriptek az egyik lehetőség, de használhatjuk az SCM lecsupaszított verzióját is, amely néhány eszközben elérhető. A Chef az egyik legnépszerűbb lehetőség, a „chef-solo” pedig a Chef önálló konfigurációs módja, ahol nincs szükségünk extra csomópontra, hogy „szakács-szerverként” működjön. Csak egy URL-re vagy egy chef szakácskönyveket tartalmazó tarball-csomag elérési útjára van szüksége. A shell szkriptekhez képest ez a fajta megközelítés sokkal deklaratívabb és hatékonyabb, és jó bevezető az SCM-ek vagy az IaC (Infrastructure as Code) folyamatok használatához.

Néhány további előny a chef-solo használatából:

• Összeállíthatóság: Használja a séf szupermarketben vagy más helyeken található közösségi szakácskönyveket.
• Ingyenes és nyílt forráskódú; a megengedő Apache 2.0 licenc alatt.
• Hozzáférés a Chef ökoszisztémájának többi részéhez (InSpec, ChefSpec, Cookstyle, Foodcritic, chef-shell stb.)
• A szakácskönyvek és receptek a későbbiekben kliens/szerver módhoz illeszthetők.

És néhány hátránya:

• Néhány közösségi szakácskönyv a Chef szupermarketben elavult, törött és nem karbantartott.
• A chef-solo önmagában nem tudja feloldani a függőségeket.

A séf „szakácskönyvében” található „receptek” rubin alapú DSL-t tartalmaznak, amely leírja, hogy az „erőforrások” egy adott állapotban legyenek egy csomóponton. Folytassuk az áttekintést, hogy megismerkedjünk néhány séf-koncepcióval, amelyek a séf-szólóra is alkalmazhatók. Célunk egy Python/Django webalkalmazást futtató Ubuntu csomópont létrehozása Gunicorn és NGINX segítségével.

Note: We do not necessarily require ChefDK to be installed on our "Chef workstation" (our machine), although with it, we can use 'chef generate' commands to start-off with a directory structure for creating cookbooks, recipes and more. In this article, we will assume ChefDK is installed on our workstation. Commands were run using the version 4.7.26-1 of ChefDK.

(Ettől a ponttól kezdve, hacsak másként nincs megadva, minden a mi gépünkön, más néven „Séf munkaállomáson” fut.)

A szakácskönyv készítése

A chef szakácskönyvei újrafelhasználható egységek, amelyek mindent tartalmaznak, ami a konfigurációs forgatókönyv támogatásához szükséges. A szakácskönyvek több „receptet” is tartalmazhatnak, és a „receptek” többnyire forrásmintákat tartalmaznak. default.rbaz alapértelmezett recept, amely akkor fut le, amikor a szakácskönyvre hivatkozik egy futtatási listában . A különböző receptek lehetővé teszik a gondok szétválasztását. Ehhez az oktatóanyaghoz azonban az összes erőforrás-deklarációt egyetlen fő receptfájlban adjuk hozzá, ez a default.rb.

Hozzon létre egy "my-chef-project" nevű mappát, és hozzon létre benne egy "szakácskönyvek" nevű mappát. innen ./my-chef-project/cookbooks/futtassa:

$ chef generate cookbook my-cookbook

A könyvtárszerkezetünk most így fog kinézni:

.
└── my-chef-project
└── cookbooks
└── my-cookbook
├── CHANGELOG.md
├── LICENSE
├── Policyfile.rb
├── README.md
├── chefignore
├── kitchen.yml
├── metadata.rb
├── recipes
│ └── default.rb
├── spec
│ ├── spec_helper.rb
│ └── unit
│ └── recipes
│ └── default_spec.rb
└── test
└── integration
└── default
└── default_test.rb

Csomagok hozzáadása

A csomópont beállításának első lépése annak meghatározása, hogy milyen csomagokra van szüksége az alkalmazásunknak. A csomópontunk az Ubuntu, így az APT csomagkezelőre támaszkodhatunk a függőségek összegyűjtésében. Az operációs rendszer disztribúciója által biztosított csomagok telepítése ezután egy szelet a tortán:

apt_update
package 'python3'
package 'python3-pip'
package 'nginx'
package 'pkg-config'
package 'libcairo2-dev'
package 'libjpeg-dev'
package 'libgif-dev'
package 'libgirepository1.0-dev'

Ezek nagyjából magától értetődőek. Az első sor frissíti az apt tárolót, a következő sorok pedig ezeket a csomagokat.

Note: The packages following 'nginx' are needed for compiling some of the python dependencies through pip. These may differ based on your python/django project dependencies specified in requirements.txt. You can use a trial and error method to determine these packages that you need to include in your cookbook. To do that, perform a manual sudo pip install -r requirements.txt (Note: This installs packages system wide!) on a freshly instantiated ubuntu machine to see if it runs successfully. If not, the stderr should give you hints on what packages are missing.

Linux felhasználók létrehozása

Miután befejeztük a szükséges csomagok hozzáadását, létre kell hoznunk egy nem privilegizált Linux-felhasználót, aki birtokolja az alkalmazás forráskódját.

user 'bob' do
  uid 1212
  gid 'users'
  home '/home/bob'
  shell '/bin/bash'
  password '$1$alilbito$C83FsODuq0A1pUMeFPeR10'
end

Vegye figyelembe, hogy a jelszó egy Linuxban használt árnyék hash formátum. OpenSSL használatával származtatható:

$ openssl passwd -1 -salt alilbitof mypassword

Beleértve az alkalmazás forrását

Most pedig vegyük bele a Django alkalmazás forráskódját a szakácskönyvünkbe. Helyezze el a forráskódot a belsejébe Ha nem létezik, hozza ./my-chef-project/cookbooks/my-cookbook/files/default/myapp/ létre a ./my-chef-project/cookbooks/my-cookbook/files/defaultkönyvtárat.

A fájlok távoli helyére a csomópontunkon való másolására vonatkozó utasításokat a remote_directory erőforrás segítségével írjuk le :

remote_directory '/home/bob/myapp' do
  source 'myapp' # This is the name of the folder containing our source code that we kept in ./my-cookbook/files/default/
  owner 'bob'
  group 'users'
  mode '0755'
  action :create
end

A python függőségek behúzása

A python csomagok telepítéséhez requirements.txthasználhatjuk az execute erőforrást egy tetszőleges parancs futtatására. Ebben az esetben a pip install parancsot kell végrehajtanunk rajta:

execute 'install python dependencies' do
  command 'pip3 install -r requirements.txt'
  cwd '/home/bob/myapp'
end

Note: Bear in mind that this is going to execute as the root user and the python libraries will be installed system-wide. If our node is designated to exclusively run this one single python app, then it isn't much of a problem. Despite that, a better option to keep things clean and sane is to find and use a community cookbook that manages python installations or 'virtualenvs'. (or at the very least, write a series of execute blocks to replicate this). Using virtualenvs in python ensures that any python based system tools or other python projects will not be affected

A Gunicorn és az NGINX beállítása

Most itt az ideje, hogy előkészítsük a Gunicorn WSGI HTTP szervert NGINX-szel, mint fordított proxyval. Az Nginxet a Django összes statikus eszközének kezelésére is használják.

A Gunicorn Ubuntu szolgáltatásként való rögzítéséhez a Systemd használható. A systemd_unit erőforrást a Chef a 12.11-es verzió óta tartalmazza.

systemd_unit 'gunicorn.service' do
  content({
  Unit: {
    Description: 'Django on Gunicorn',
    After: 'network.target',
  },
  Service: {
    ExecStart: '/usr/local/bin/gunicorn --workers 3 --bind localhost:8080 myapp.wsgi:application',
    User: 'bob',
    Group: 'www-data',
    WorkingDirectory: '/home/bob/myapp'
    Restart: 'always',
  },
  Install: {
    WantedBy: 'multi-user.target',
  }
  })
  action [:create, :enable, :start]
end

Most egy szabványos NGINX proxy konfigurációt kell beépítenünk ehhez a Gunicorn szerverhez az alábbiak szerint. Ez a részlet bekerülhet a következőbe ./my-cookbook/templates/nginx.conf.erb. Ha nem létezik, hozza létre a sablonkönyvtárat.

Note: Chef's templates support embedded ruby files that can contain variables, ruby expressions and statements. Although this file has the 'erb' extension, we did not use any of the ruby statements or expressions. Also, for the sake of simplicity, we only have a non HTTPS nginx config here (gentle reminder; please do not do this in production!)

server {
  listen 80;
  server_name http://example.com/;

  location = /favicon.ico { access_log off; log_not_found off; }
  location /static/ {
    root /home/bob/myapp/myapp/static;
  }

  location / {
  include proxy_params;
    proxy_pass http://localhost:8080/;
  }
}

Note: There is also an alternative and a better config, where, for instance the Gunicorn server is bound to a unix domain socket instead of a TCP loopback connection. It's worth exploring that for performance reasons.

Ha át szeretné másolni ezt a konfigurációt a csomópont webhelyek-kompatibilis mappájába, használja a Chef sablon erőforrását.

template '/etc/nginx/sites-available/example.com.conf' do
  source 'nginx.conf.erb'
  owner 'root'
  group 'root'
  mode '0744'
end

A konfigurációk aktiválása az nginx-en általában úgy történik, hogy létrehoz egy szimbolikus hivatkozást, sites-availableamely az nginx sites-enabledmappájában található konfigurációra mutat . Symlinks lehet bejelenteni szakács szakácskönyvek a linket erőforrást mutat az alábbi:

link '/etc/nginx/sites-enabled/example.com.conf' do
  to '/etc/nginx/sites-available/example.com.conf'
end

és az alapértelmezett konfigurációs hivatkozás törléséhez:

link '/etc/nginx/sites-enabled/default' do
  action :delete
end

NGINX indítása

És végül az nginx szolgáltatás elindításához:

service 'nginx' do
  action :enable
  action :start
end

Futólisták

A séf futtatási listái a szerepek vagy receptek rendezett listája egy szakácskönyvben, amelyek sorrendben kerülnek végrehajtásra a csomóponton. Van egy szakácskönyvünk, a "my-cookbook" és benne az "alapértelmezett" recept, amelyet az Ubuntu dobozon kell végrehajtanunk, így a projektkönyvtárunkban ( ./my-chef-project/runlist.json) a runlist.json fájlnak így kell kinéznie:

{
  "run_list": [
    "recipe[my-cookbook::default]"
  ]
}

Utolsó lépések

Felszolgálásra kész szakácskönyvünk séf egyéni számára. Itt az ideje, hogy biztosítsunk egy Ubuntu 18.04-es gépet, és telepítsük rá a ChefDK-t:

$ ssh [email protected] 'apt-get update && yes | apt-get install curl && curl https://packages.chef.io/files/current/chefdk/4.7.45/ubuntu/18.04/chefdk_4.7.45-1_amd64.deb -o chefdk.deb && yes | dpkg -i chefdk.deb && rm chefdk.deb'

Visszatérve a Chef munkaállomásra , mindössze annyit kell tennünk, hogy a szakácskönyvek mappát egy tarballba helyezzük, átmásoljuk azt a tarballal együtt a runlist.jsonfent megadott távoli csomópontra, és futtassuk a chef-solo parancsot:

(Az alábbi parancsot a csomóponton vagy a 'chef kliensen' kell futtatni, nem pedig a Chef munkaállomáson)

$ chef-solo --recipe-url $(pwd)/chef-solo.tar.gz -j $(pwd)/runlist.json --chef-license=accept

Vagy itt van egy egysoros (a ./my-chef-project/CWD-ről kell futtatni a Chef Workstationen):

tar zvcf chef-solo.tar.gz ./cookbooks &&\
scp chef-solo.tar.gz runlist.json [email protected]:~/ &&\
ssh [email protected] 'chef-solo --recipe-url $(pwd)/chef-solo.tar.gz -j $(pwd)/runlist.json --chef-license=accept'

Ez az! Nézze meg, ahogy a standard kimenet megtelik a Chef tevékenységgel, amely megpróbálja konvergálni a csomópontot a szakácskönyvekben megadottakhoz. A Chef-solo minden szakácskönyvhöz szükséges gyöngyszemet telepít. Ha a chef-solo parancs sikeres, akkor az nginx mögött egy működő Django alkalmazás fog futni az Ubuntu dobozon. A teszteléshez navigáljon a tartományhoz/IP-hez.

Note: Remember that in django you may need to set this domain/ip in the ALLOWED_HOSTS list in settings.py.

Válasz a változásokra

Amikor módosítunk projektkönyvtárunk tartalmában (receptek, sablonok vagy az alkalmazás forráskódja stb.), egyszerűen futtassa a fenti egysorost a projektkönyvtárból.

Tip: If the cookbook is version controlled with git (as it should), one good recommendation is to set git hooks to run this one-liner.

A tarball tárolása (opcionális)

Ha alaposan megnézi az utolsó chef-solo parancsot, vegye észre, hogy a parancs --recipe-urlegy URL-címet jelent. Ez azt jelenti, hogy rendelkezhet egy munkafolyamattal, amelyben a CI összeállítja a chef-solo tarballt, feltölti valahova, és beállítja a csomópontot, hogy rendszeresen húzzon belőle.

Tip: Use curl to pull the changed tarball periodically as a cronjob. curl -z $file will honor If-Modified-Since headers and will only download the tar ball if the remote file has been changed since the timestamp on the existing local $file.