Chef-solo kasutamine Django rakenduse konfigureerimiseks Ubuntus

Kasti seadistamise ja seadistamise protsessi automatiseerimiseks on palju võimalusi. Mingil põhjusel, kui kogu meie süsteem koosneb praegu vaid ühest kastist, on täieliku SCM-i (tarkvara konfiguratsioonihalduse) infrastruktuuri seadistamine üle jõu käiv. Shelliskriptid on üks võimalus, kuid me võiksime kasutada ka SCM-i vähendatud versiooni, mis on saadaval mõnes seal pakutavas tööriistas. Chef on üks populaarsemaid valikuid ja "chef-solo" on Chefi eraldiseisev konfiguratsioonirežiim, kus me ei vaja "koka-serverina" toimimiseks lisasõlme. Kõik, mida see vajab, on URL või tee tarballi paketi juurde, mis sisaldab koka kokaraamatuid. Võrreldes shelliskriptidega on seda tüüpi lähenemine deklaratiivsem ja tõhusam juba algusest peale ning on ka hea sissejuhatus SCM-i või IaC (infrastruktuur kui kood) protsessidega alustamiseks.

Mõned muud eelised chef-solo kasutamisel:

• Komponeeritavus: kasutage kogukonna kokaraamatuid kokkade supermarketist või muudest kohtadest.
• Tasuta ja avatud lähtekoodiga; litsentsitud lubava Apache 2.0 litsentsi alusel.
• Juurdepääs ülejäänud peakoka ökosüsteemile (InSpec, ChefSpec, Cookstyle, Foodcritic, chef-shell jne)
• Kokaraamatuid ja retsepte saab hiljem kohandada kliendi/serveri režiimiga.

Ja mõned miinused:

• Mõned Chefi supermarketi kogukonna kokaraamatud on aegunud, katkised ja neid ei hooldata.
• chef-solo ei suuda sõltuvusi üksi lahendada.

Koka „kokaraamatu“ sees olevatel „retseptidel“ on rubiinipõhine DSL, mis kirjeldab „ressursse“, mis on sõlme teatud olekus. Jätkame läbivaatusega, et tutvuda mõne peakoka kontseptsiooniga, mis kehtivad ka peakokk-soolo puhul. Meie eesmärk on Gunicorni ja NGINXi abil seadistada Ubuntu sõlm, mis käitab Pythoni/Django veebirakendust.

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.

(Kõik sellest hetkest alates, kui pole teisiti määratud, töötab meie masinas, mida nimetatakse ka koka tööjaamaks)

Kokaraamatu koostamine

Kokaraamatud on korduvkasutatavad üksused, mis sisaldavad kõike konfiguratsioonistsenaariumi toetamiseks vajalikku. Kokaraamatud võivad sisaldada mitut "retsepti" ja "retseptid" koosnevad enamasti ressursside mustritest. default.rbon vaikeretsept, mida käivitatakse, kui kokaraamatule viidatakse käitamisloendis . Erinevad retseptid võimaldavad muresid lahutada. Selle õpetuse jaoks lisame aga kõik ressursideklaratsioonid ühte peamisse retseptifaili, milleks on default.rb.

Looge kaust nimega "minu-koka projekt" ja looge selle sees kaust "kokaraamatud". Alates ./my-chef-project/cookbooks/, käivitage:

$ chef generate cookbook my-cookbook

Meie kataloogi struktuur näeb nüüd välja selline:

.
└── 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

Pakkide lisamine

Meie sõlme seadistamise esimene samm on tuvastada, milliseid pakette meie rakendus nõuab. Meie sõlm on valitud Ubuntuks, nii et saame sõltuvuste kogumisel tugineda APT paketihaldurile. OS-i distributsiooni pakutavate pakettide installimine on siis käkitegu:

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'

Need on üsna iseenesestmõistetavad. Esimene rida värskendab sobivat hoidlat ja järgmised read installivad need paketid.

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.

Linuxi kasutajate loomine

Kui oleme nõutavate pakettide lisamise lõpetanud, peame looma privilegeeritud Linuxi kasutaja, kellele kuulub rakenduse lähtekood.

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

Pange tähele, et parool on Linuxis kasutatav variräsivorming. Seda saab tuletada OpenSSL-i abil:

$ openssl passwd -1 -salt alilbitof mypassword

Sealhulgas rakenduse allikas

Nüüd lisame oma kokaraamatusse Django rakenduse lähtekoodi. Asetage lähtekood sisse ./my-chef-project/cookbooks/my-cookbook/files/default/myapp/ Loo ./my-chef-project/cookbooks/my-cookbook/files/defaultkataloog, kui seda pole olemas.

Juhiseid nende failide kopeerimiseks meie sõlme kaugasukohta kirjeldatakse Remote_directory ressursi abil:

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

Püütoni sõltuvuste tõmbamine

Pythoni pakettide installimiseks rakendusse requirements.txtsaame kasutada täitmisressurssi suvalise käsu käivitamiseks. Sel juhul peame selle kohal täitma pip install käsu:

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

Gunicorni ja NGINX-i seadistamine

Nüüd on aeg ette valmistada Gunicorn WSGI HTTP-server, mille pöördpuhverserver on NGINX. Nginxit kasutatakse ka kõigi Django staatiliste varade haldamiseks.

Gunicorni ühendamiseks Ubuntu teenusena saab kasutada Systemdi. Systemd_unit ressurss on lisatud Chef alates versioonist 12.11.

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

Nüüd peame sellesse Gunicorni serverisse lisama standardse NGINX-i puhverserveri konfiguratsiooni, nagu allpool näidatud. See väljavõte võib minna ./my-cookbook/templates/nginx.conf.erb. Loo mallide kataloog, kui seda pole olemas.

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.

Kopeerida üle selle config saitidele-toega kausta sõlme, kasutada malli ressurss Chef.

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

Konfiguratsioonide aktiveerimine nginxis toimub tavaliselt sümlingi loomisega, mis osutab sites-availablenginxi sites-enabledkaustas olevale konfiguratsioonile . Nimeviitade saab deklareeritud kokk kokaraamatud koos link ressursi nagu näitavad allpool:

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

ja vaikekonfiguratsiooni sümbolilingi kustutamiseks:

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

NGINX-i käivitamine

Ja lõpuks, nginxi teenuse käivitamiseks:

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

Jooksunimekirjad

Run-lists in chef are an ordered list of roles or recipes in a cookbook that will be executed in sequence on the node. We have one cookbook "my-cookbook" and the "default" recipe inside it that we need to execute on the Ubuntu box, so the runlist.json in our project directory (./my-chef-project/runlist.json) should look like this:

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

Final steps

Our cookbook for Chef solo is ready to be served. It's time to provision an Ubuntu 18.04 machine and install ChefDK on it:

$ 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'

Going back to our Chef workstation, all we need to do is put the cookbooks folder inside a tarball, transfer that tarball along with the runlist.json to the remote node we provisioned above and run the chef-solo command:

(The below command is to be run inside the node or the 'chef client' and not the Chef Workstation)

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

Or here's a one-liner (To be run from ./my-chef-project/ CWD on Chef Workstation):

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'

That's it! Watch the standard output fill up with Chef activity trying to converge your node to what you've specified in the cookbooks. Chef-solo will install all the gems required for all the cookbooks. If the chef-solo command is successful, we will have a working Django application running behind nginx on the Ubuntu box. Navigate to the domain/IP to test it.

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

Responding to changes

Whenever we make a change in the content of our project directory (recipes, templates or the application source code etc), simply run the above one-liner from the project directory.

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.

Hosting the tarball (optional)

If you look closely at the last chef-solo command, notice that the --recipe-url is meant to take a URL. This means that you can have a workflow where a CI will build your chef-solo tarball, upload it someplace and configure your node to pull from it periodically.

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.