Używanie Chef-solo do konfigurowania aplikacji Django na Ubuntu

• Tworzenie książki kucharskiej
• Ostatnie kroki

Istnieje wiele sposobów na zautomatyzowanie procesu konfiguracji i konfiguracji skrzynki. Z jakiegokolwiek powodu, jeśli cały nasz system w tym momencie składa się tylko z jednej skrzynki, skonfigurowanie pełnej infrastruktury SCM (Software Configuration Management) to przesada. Skrypty powłoki są jedną z opcji, ale możemy również użyć uproszczonej wersji SCM, która jest dostępna w kilku dostępnych narzędziach. Chef jest jedną z popularnych opcji, a „chef-solo” to samodzielny tryb konfiguracji szefa kuchni, w którym nie potrzebujemy dodatkowego węzła, aby działał jako „kucharz-serwer”. Wszystko czego potrzebuje to adres URL lub ścieżka do pakietu tarball, który zawiera książki kucharskie. W porównaniu ze skryptami powłoki ten rodzaj podejścia jest bardziej deklaratywny i wydajny od samego początku, a także stanowi dobre wprowadzenie do rozpoczęcia pracy z SCM lub procesami IaC (Infrastructure as Code).

Kilka innych korzyści z używania szefa kuchni solo:

• Kompozycyjność: korzystaj ze wspólnotowych książek kucharskich z supermarketu szefa kuchni lub innych miejsc.
• Darmowe i otwarte oprogramowanie; licencjonowane na podstawie zezwolenia Apache 2.0.
• Dostęp do reszty ekosystemu szefa kuchni (InSpec, ChefSpec, Cookstyle, Foodcritic, szef kuchni itp.)
• Książki kucharskie i przepisy można później dostosować do trybu klient / serwer.

I niektóre wady:

• Niektóre społeczne książki kucharskie w supermarkecie szefa kuchni są nieaktualne, zepsute i nie są utrzymywane.
• szef kuchni solo nie jest w stanie samodzielnie rozwiązać zależności.

„Przepisy” w „książce kucharskiej” szefa kuchni oparte są na ruby ​​DSL, która opisuje „zasoby”, które mają znajdować się w określonym stanie w węźle. Przejdźmy do przewodnika, aby zapoznać się z kilkoma koncepcjami szefa kuchni, które mają również zastosowanie do szefa kuchni solo. Naszym celem jest skonfigurowanie węzła Ubuntu z uruchomioną aplikacją internetową Python / Django przy użyciu Gunicorn i NGINX.

Uwaga: niekoniecznie wymagamy, aby ChefDK był zainstalowany na naszej „stacji roboczej szefa kuchni” (naszej maszynie), chociaż za jego pomocą możemy użyć poleceń „generowania szefa kuchni”, aby rozpocząć od struktury katalogów do tworzenia książek kucharskich, przepisów kulinarnych i innych. W tym artykule założymy, że ChefDK jest zainstalowany na naszej stacji roboczej. Polecenia były uruchamiane przy użyciu wersji 4.7.26-1 programu ChefDK.

(Wszystko od tego momentu, o ile nie zaznaczono inaczej, ma być uruchamiane na naszym komputerze, zwanym także „stanowiskiem szefa kuchni”)

Tworzenie książki kucharskiej

Książki kucharskie w kuchni są jednostkami wielokrotnego użytku, które zawierają wszystko, co jest potrzebne do wsparcia scenariusza konfiguracji. Książki kucharskie mogą zawierać wiele „przepisów”, a „przepisy” składają się głównie z wzorców zasobów. default.rbto domyślny przepis, który zostanie uruchomiony, gdy książka kucharska zostanie wymieniona na liście run-run . Różne przepisy pozwalają rozdzielić obawy. W tym samouczku dodamy jednak wszystkie deklaracje zasobów do jednego głównego pliku receptury, którym jest default.rb.

Utwórz folder o nazwie „my-chef-project” i utwórz w nim folder o nazwie „książki kucharskie”. Od ./my-chef-project/cookbooks/, uruchom:

$ chef generate cookbook my-cookbook

Nasza struktura katalogów będzie teraz wyglądać następująco:

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

Dodawanie pakietów

Pierwszym krokiem do skonfigurowania naszego węzła jest określenie, jakie pakiety są wymagane przez naszą aplikację. Nasz węzeł został wybrany jako Ubuntu, więc możemy polegać na menedżerze pakietów APT w celu zebrania zależności. Instalowanie pakietów dostarczanych przez dystrybucję systemu operacyjnego jest więc dziecinnie proste:

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'

Są to dość oczywiste. Pierwszy wiersz zaktualizuje repozytorium apt, a kolejne wiersze zainstalują te pakiety.

Uwaga: Pakiety następujące po 'nginx' są potrzebne do kompilacji niektórych zależności Pythona przez pip. Mogą się one różnić w zależności od zależności projektu w Pythonie / django określonych w requirements.txt. Możesz użyć metody prób i błędów, aby określić te pakiety, które musisz uwzględnić w książce kucharskiej. Aby to zrobić, wykonaj instrukcję sudo pip install -r requirements.txt(Uwaga: Instaluje pakiety w całym systemie!) Na świeżo utworzonej maszynie Ubuntu, aby sprawdzić, czy działa poprawnie. Jeśli nie, stderr powinien dać ci wskazówki, jakich paczek brakuje.

Tworzenie użytkowników Linuksa

Po zakończeniu dodawania wymaganych pakietów musimy utworzyć nieuprzywilejowanego użytkownika systemu Linux, który będzie właścicielem kodu źródłowego aplikacji.

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

Pamiętaj, że hasło to format skrótu w tle używany w systemie Linux. Można go uzyskać za pomocą OpenSSL:

$ openssl passwd -1 -salt alilbitof mypassword

W tym źródło aplikacji

Teraz dołączmy kod źródłowy aplikacji Django do naszej książki kucharskiej. Umieść kod źródłowy w środku ./my-chef-project/cookbooks/my-cookbook/files/default/myapp/ Utwórz ./my-chef-project/cookbooks/my-cookbook/files/defaultkatalog, jeśli nie istnieje.

Instrukcja kopiowania tych plików do zdalnej lokalizacji w naszym węźle została opisana przy użyciu zasobu katalog_zdalny :

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

Wciąganie zależności Pythona

Aby zainstalować pakiety Pythona requirements.txt, możemy użyć zasobu wykonawczego do uruchomienia dowolnego polecenia. W takim przypadku musimy wykonać nad nim polecenie pip install:

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

Uwaga: pamiętaj, że zostanie to wykonane jako użytkownik root, a biblioteki Pythona zostaną zainstalowane w całym systemie. Jeśli nasz węzeł jest przeznaczony wyłącznie do uruchamiania tej jednej aplikacji w Pythonie, nie stanowi to większego problemu. Mimo to lepszym sposobem na utrzymanie porządku i rozsądku jest znalezienie i korzystanie ze społecznościowej książki kucharskiej zarządzającej instalacjami w języku Python lub „virtualenvs”. (lub przynajmniej napisz serię bloków wykonawczych, aby to powielić). Korzystanie z virtualenvs w Pythonie gwarantuje, że nie wpłynie to na żadne narzędzia systemowe oparte na Pythonie ani inne projekty Pythona

Konfiguracja Gunicorn i NGINX

Teraz nadszedł czas na przygotowanie serwera HTTP Gunicorn WSGI z NGINX jako naszym odwrotnym proxy. Nginx służy również do obsługi wszystkich zasobów statycznych z Django.

Aby połączyć Gunicorn jako usługę na Ubuntu, można użyć Systemd. Systemd_unit zasób znajduje się w szefa kuchni od wersji 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

Teraz musimy dołączyć standardową konfigurację proxy NGINX do tego serwera Gunicorn, jak pokazano poniżej. Do tego fragmentu można się dostać ./my-cookbook/templates/nginx.conf.erb. Utwórz katalog szablonów, jeśli nie istnieje.

Uwaga: Szablony szefa kuchni obsługują osadzone pliki ruby, które mogą zawierać zmienne, wyrażenia i instrukcje ruby. Chociaż ten plik ma rozszerzenie „erb”, nie użyliśmy żadnych instrukcji lub wyrażeń ruby. Ponadto, dla uproszczenia, mamy tutaj tylko konfigurację nginx inną niż HTTPS (delikatne przypomnienie; nie rób tego podczas produkcji!)

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/;
  }
}

Uwaga: Istnieje również alternatywna i lepsza konfiguracja, w której na przykład serwer Gunicorn jest powiązany z gniazdem domeny unix zamiast połączenia zwrotnego TCP. Warto to zbadać ze względu na wydajność.

Aby skopiować tę konfigurację do folderu obsługującego witryny w węźle, użyj zasobu szablonu od szefa kuchni.

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

Aktywacja konfiguracji na nginx zwykle odbywa się poprzez utworzenie dowiązania symbolicznego wskazującego na config sites-availablew sites-enabledfolderze nginx . Łącza symboliczne można zadeklarować w książkach kucharskich za pomocą zasobu łącza, jak pokazano poniżej:

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

i aby usunąć domyślne łącze symboliczne konfiguracji:

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

Uruchamianie NGINX

I wreszcie, aby uruchomić usługę Nginx:

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

Listy Run

Listy uruchomień w szefie kuchni to uporządkowana lista ról lub przepisów w książce kucharskiej, które będą wykonywane sekwencyjnie w węźle. Mamy jedną książkę kucharską „moja książka kucharska” i „domyślny” przepis, który musimy wykonać na polu Ubuntu, więc runlist.json w naszym katalogu projektu ( ./my-chef-project/runlist.json) powinien wyglądać następująco:

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

Ostatnie kroki

Nasza książka kucharska dla szefa kuchni solo jest gotowa do podania. Czas udostępnić maszynę Ubuntu 18.04 i zainstalować na niej ChefDK:

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

Wracając do naszej stacji roboczej szefa kuchni , wystarczy umieścić folder książek kucharskich w pliku tarball, przenieść ten plik tarball wraz ze runlist.jsonzdalnym węzłem, który udostępniliśmy powyżej, i uruchomić polecenie szefa kuchni solo:

(Poniższe polecenie należy uruchomić w węźle lub „kliencie szefa kuchni”, a nie w stacji roboczej szefa kuchni)

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

Lub tutaj jest jeden linijka (do uruchomienia z ./my-chef-project/CWD na stacji roboczej szefa kuchni):

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'

Otóż ​​to! Zobacz, jak standardowe dane wyjściowe wypełniają się aktywnością Szefa kuchni, starając się połączyć węzeł z tym, co określiłeś w książkach kucharskich. Chef-solo zainstaluje wszystkie klejnoty wymagane dla wszystkich książek kucharskich. Jeśli polecenie szefa kuchni-solo się powiedzie, będziemy mieć działającą aplikację Django działającą za nginx na polu Ubuntu. Przejdź do domeny / adresu IP, aby go przetestować.

Uwaga: Pamiętaj, że w django może być konieczne ustawienie tej domeny / ip na ALLOWED_HOSTSliście w settings.py.

Reagowanie na zmiany

Ilekroć wprowadzamy zmiany w treści naszego katalogu projektu (przepisy, szablony lub kod źródłowy aplikacji itp.), Po prostu uruchom powyższą linijkę z katalogu projektu.

Wskazówka: Jeśli książka kucharska jest kontrolowana w wersji za pomocą git (tak jak powinna), dobrym pomysłem jest ustawienie haków git, aby uruchamiały tę linijkę.

Hostowanie tarballa (opcjonalnie)

Jeśli przyjrzysz się uważnie ostatniemu poleceniu szefa kuchni solo, zwróć uwagę, że --recipe-urljest to adres URL. Oznacza to, że możesz mieć przepływ pracy, w którym CI zbuduje tarballa szefa kuchni-solo, załaduje go gdzieś i skonfiguruje węzeł, aby okresowo z niego pobierał.

Wskazówka: Użyj curl, aby okresowo wyciągać zmienione archiwum jako cronjob. curl -z $filehonoruje If-Modified-Sincenagłówki i pobiera tar tar, jeśli plik zdalny został zmieniony od czasu znacznika czasu na istniejącym pliku lokalnym $file.