Przejdź do głównej zawartości
AggregaAggrega
Wybierz język: Polski
Ta strona została przetłumaczona maszynowo. Przeczytaj oryginał w języku angielskim.

Pliki budowania

Ta strona wyjaśnia jedną ideę, czyli który plik budowania mówi co, i nie jest uruchamialnym obszarem roboczym. Aplikacja webowa z PostgreSQL, budowana krok po kroku pokazuje ją w obszarze roboczym przeznaczonym do zbudowania; można go zapisać we własnym folderze poleceniem:

Terminal window
aggrega scaffold --example quickstart-web

Następnie wypisuje polecenia do uruchomienia w dalszej kolejności:

Terminal window
cd quickstart-web
cd 1
aggrega build --release release.yaml --auto-pull
export QUICKSTART_DB_PASSWORD=choose-a-password
docker compose -p quickstart-web -f dist/compose/docker-compose.yaml up -d --wait
# then open http://127.0.0.1:8080/ in your browser

Pięć rodzajów plików, każdy z jednym autorem

Budowanie odczytuje pięć rodzajów plików. Każdy mówi jedną rzecz, a w typowym zespole każdy ma własnego autora:

  • encja Component określa, czym jest dany rodzaj komponentu: jakie wartości może ustawić deweloper, jakie ustawienia infrastruktury może ustawić operator, co publikuje komponentom, które się z nią łączą, oraz przez jakie gniazda się łączy. Katalog biblioteki standardowej zawiera encje Components potrzebne większości aplikacji, takie jak core/datastore/postgres i core/compute/server, więc obszar roboczy zwykle nie zapisuje żadnej;
  • encja Aggregate należy do dewelopera: jakie komponenty ma aplikacja i z czym łączy się każdy z nich;
  • encja Recipe przekształca jeden rodzaj komponentu w pliki dla jednego narzędzia — usługę Compose, chart Helm, moduł Terraform;
  • encja Manifest wybiera, która encja Recipe realizuje każdy rodzaj komponentu dla jednego celu;
  • encja Release wskazuje encję Aggregate i encję Manifest oraz podaje ustawienia jednego środowiska. To ją się buduje: aggrega build --release release.yaml.

Ten podział jest wskazówką: jedna osoba może napisać wszystkie pięć, a budowanie akceptuje każdy z nich, o ile każdy jest poprawny.

Encja Aggregate: komponenty i ich połączenia

Pierwszym krokiem przykładu jest aplikacja webowa i jej baza danych. Jej encja Aggregate, z pliku 1/aggregate.yaml z pominięciem komentarzy:

spec:
components:
web:
type: core/compute/server
features:
db_password:
type: core/secret-value
values:
key: PGPASSWORD
origin: "${QUICKSTART_DB_PASSWORD}"
uses:
database:
db:
target: db
inject:
env:
- in: PGHOST
from: host
- in: PGPORT
from: port
- in: PGUSER
from: user
- in: PGDATABASE
from: database
db:
type: core/datastore/postgres
features:
password:
type: core/secret-value
values:
key: POSTGRES_PASSWORD
origin: "${QUICKSTART_DB_PASSWORD}"

Nic tutaj nie wskazuje portu, hosta, przestrzeni nazw ani narzędzia. web łączy się z db przez swoje gniazdo database, a lista inject mówi, która zmienna aplikacji otrzymuje każdy wpis publikowany przez bazę danych: from: wskazuje wpis, in: zmienną.

Połączenie to ciąg znaków przekazywany potokiem

Encja Recipe bazy danych publikuje host, port, user i database, aby połączenie mogło je odczytać. To, jaki adres zawiera host, zależy od encji Recipe wybranej przez encję Manifest: nazwa usługi, gdy baza danych działa obok aplikacji, ciąg wskaźnikowy, który narzędzie do provisioningu rozwiązuje dla zarządzanej bazy danych, albo adres serwera, który już istnieje. Budowanie kopiuje każdy opublikowany ciąg do zmiennej wskazanej przez encję Aggregate i go nie interpretuje: nigdy nie rozwiązuje adresu ani nie sprawdza, czy jest osiągalny.

Encje Manifest i Release

Encja Manifest z pliku 1/manifest.yaml wiąże każdy rodzaj komponentu, a także dołączenia haseł, z encją Recipe, która realizuje go w Docker Compose:

spec:
mappings:
components:
type:
core/compute/server:1.1.0: compose/server:2.0.0
core/datastore/postgres:1.0.0: compose/postgres:1.0.0
features:
type:
core/secret-value:1.0.0: compose/dotenv-secret:1.0.0

Encja Release z pliku 1/release.yaml wskazuje encję Aggregate i encję Manifest oraz podaje to, co wie tylko środowisko, tutaj obraz uruchamiany przez aplikację, port, na którym nasłuchuje, i port, na którym Docker Compose publikuje ją pod adresem pętli zwrotnej komputera (ze skróconym digestem obrazu):

spec:
aggregate: quickstart-web
manifest: quickstart-web-compose
components:
web:
infra:
image: hub.aggrega.ai/tools/quickstart-web:1.1.0@sha256:…
port: 8080
published_port: 8080
db: {}

Kolejne kroki przykładu go rozbudowują: pamięć podręczna Redis obok bazy danych, potem te same komponenty w AWS za pomocą Terraform, a potem kopie zapasowe bazy danych.

Parametry: jedna encja Aggregate, wiele środowisk

Wartość, która różni się między środowiskami, deklaruje się w encji Aggregate jako typowany parametr, odwołuje się do niej tam, gdzie jest używana, a podaje ją każda encja Release. W przykładzie Zadanie uruchamiane na żądanie encja Aggregate deklaruje harmonogram swojego raportu:

spec:
parameters:
report_schedule:
type: string
default: ""
components:
report:
type: core/compute/task
values:
schedule: "{{ .parameters.report_schedule }}"

a encja Release go wypełnia:

spec:
parameters:
report_schedule: "30 2 * * 1-5"

Budowanie sprawdza każdą wartość podaną przez encję Release względem typu parametru, zanim wypełni szablon. Encja Release nigdy sama nie zapisuje values komponentu: wypełnia parametry udostępniane przez encję Aggregate, dzięki czemu encja Aggregate pozostaje jedynym miejscem, które mówi, jakie wartości różnią się w zależności od środowiska. Encja Release może też odczytać swoje parametry z osobnego pliku, parameters: { $import: ./env/prod-values.yaml }.