Un task eseguito su richiesta: un Aggregate, quattro target
Un task che porta core/manual-trigger, distribuito senza essere avviato su Kubernetes, Docker Compose, Terraform e CloudFormation, accanto a un task che non porta nulla, con il comando che avvia un’esecuzione su ciascun target.
Alcuni lavori vengono eseguiti fino al completamento solo quando qualcuno li richiede: una correzione dei dati una tantum, un backup su richiesta. core/manual-trigger è la Feature per questo. Associata a un core/compute/task senza programmazione, distribuisce il task senza avviarlo, e ogni esecuzione è una che qualcuno avvia a mano, con il comando proprio del target.
Questo workspace esegue la build di un unico Aggregate per quattro target — Kubernetes tramite Helm, Docker Compose, Terraform e CloudFormation — e mostra, su ciascuno, che cosa l’associazione cambia nell’output renderizzato e il comando che avvia un’esecuzione. Il secondo task non porta alcuna associazione, quindi la differenza è visibile nella stessa build. Altre due Releases sono destinate ad arrestarsi, e la pagina riporta ciò che ciascuna stampa.
Che cosa costruisce
| istanza | Component del catalogo | associazione | che cosa avvia un’esecuzione |
|---|---|---|---|
data-fix | core/compute/task | core/manual-trigger | qualcuno, a mano, su ogni target |
report | core/compute/task | nessuna | la sua programmazione oppure, su Docker Compose, l’avvio dello stack |
L’associazione si trova nell’Aggregate, accanto al task che modifica: l’esecuzione su richiesta fa parte di ciò che data-fix è, quindi la scrive lo sviluppatore, e la Feature non accetta né valori né infra. La Release non scrive nulla per essa.
La programmazione di report è un parametro, report_schedule, che l’Aggregate dichiara con un valore predefinito vuoto e legge nel valore schedule del task:
spec: parameters: report_schedule: type: string default: "" [… omitted: the parameter's description]
components: [… omitted: data-fix with its attachment, and the comment above each task] report: type: core/compute/task values: schedule: "{{ .parameters.report_schedule }}"È un parametro perché i quattro target non concordano su un task senza associazione. Kubernetes lo esegue secondo una programmazione come CronJob, oppure una sola volta al momento della distribuzione se non ne ha una. Docker Compose non ha uno scheduler, quindi esegue il task una volta a ogni avvio dello stack e rifiuta una programmazione. Su AWS nulla esegue un task Amazon ECS quando Terraform o CloudFormation applica la configurazione, quindi lì un task ha bisogno di una programmazione o dell’associazione, e senza nessuna delle due viene rifiutato. Per questo le Releases Kubernetes, Terraform e CloudFormation soddisfano report_schedule, e la Release Docker Compose lo lascia vuoto.
La build di data-fix avviene allo stesso modo su tutti e quattro, senza programmazione e senza parametro.
Le sei Releases
| Release | Manifest | report_schedule | il build |
|---|---|---|---|
release-helm.yaml | manifest-helm.yaml | 30 2 * * 1-5 | va a buon fine |
release-compose.yaml | manifest-compose.yaml | vuoto | va a buon fine |
release-terraform.yaml | manifest-terraform.yaml | 30 2 * * 1-5 | va a buon fine |
release-cloudformation.yaml | manifest-cloudformation.yaml | 30 2 * * 1-5 | va a buon fine |
release-compose-scheduled.yaml | manifest-compose.yaml | 30 2 * * 1-5 | si arresta |
release-terraform-unscheduled.yaml | manifest-terraform.yaml | vuoto | si arresta |
Ogni Manifest mappa core/compute/task sulla Recipe del proprio target e lega core/manual-trigger alla FeatureRecipe del proprio target: helm/task e helm/manual-trigger, compose/task e compose/manual-trigger, terraform/task-ecs e terraform/manual-trigger, e cloudformation/task-ecs e cloudformation/manual-trigger. Un Manifest che non lega alcuna FeatureRecipe per l’associazione arresta la build, nominandola.
Ogni Release nomina sotto infra.image l’immagine che ciascun task esegue, poiché core/compute/task non contiene alcun software. Le Releases AWS nominano anche, sotto infra.overrides, il cluster, le subnet, i security group e il ruolo di esecuzione con cui viene eseguito ciascun task e, dove report ha una programmazione, il ruolo con cui la programmazione avvia ciascuna esecuzione. Ogni valore specifico dell’account lì presente è un segnaposto.
Generare l’esempio
Puoi eseguire la build di questo esempio con i comandi qui sotto, oppure farla eseguire al tuo assistente IA.
Scrivi l’esempio in una nuova cartella che porta il suo nome:
aggrega scaffold --example task-run-on-demandPoi stampa i prossimi comandi da eseguire. Il primo ti porta nella nuova cartella:
cd task-run-on-demandBuild
Il workspace legge il catalogo della libreria standard dal registry dell’hub che .aggrega-config.yaml nomina. Ogni Recipe qui viene renderizzata dal solo catalogo, quindi ogni build viene eseguita offline una volta risolto il lockfile.
aggrega build --release release-helm.yaml --auto-pull # one ReleaseIn un checkout del repository della documentazione, che contiene lo script di supporto al build condiviso che una copia scritta da aggrega scaffold --example non porta con sé, ./check.sh esegue il build di tutte e sei le Releases e controlla l’esito di ciascuna. Stampa una riga per Release ed esce con 0 solo quando ciascuna si è conclusa come descrive questa pagina:
RELEASE EXIT EXPECTED VERDICT----------------------------------------------------------------------------------------------------release-helm.yaml 0 complete OK: completed, the files the README showsrelease-compose.yaml 0 complete OK: completed, the files the README showsrelease-terraform.yaml 0 complete OK: completed, the files the README showsrelease-cloudformation.yaml 0 complete OK: completed, the files the README showsrelease-compose-scheduled.yaml 1 halt OK: halted with the expected refusalrelease-terraform-unscheduled.yaml 1 halt OK: halted with the expected refusal
check: every build ended as expected.Con un assistente AI
Un assistente IA configurato con gli strumenti di Aggrega può fare lo stesso: incolla questo prompt nell’assistente.
Usa solo gli strumenti di Aggrega e non creare tu alcuna cartella. Se la cartella dell’area di lavoro non contiene ancora una cartella `task-run-on-demand`, chiama una volta lo strumento `scaffold` con `example` impostato su `task-run-on-demand` e senza `dir`: scrive l’esempio in una nuova cartella `task-run-on-demand`. Poi chiama lo strumento `build` con `workspace_root` impostato su `task-run-on-demand`, `release` impostato su `release-helm.yaml`, `auto_pull` impostato su true e `write` impostato su true. Dimmi quali file ha scritto la build; si trovano sotto `task-run-on-demand/dist/`.Kubernetes
release-helm.yaml scrive due file, un CronJob per task, e nient’altro. data-fix è un CronJob tenuto sospeso, secondo una programmazione che lo sviluppatore non ha mai scritto:
apiVersion: batch/v1kind: CronJobmetadata: name: data-fix [… omitted: the labels and annotations the build writes on every resource]spec: schedule: 0 0 30 2 * suspend: true jobTemplate: spec: template: [… omitted: the pod template's metadata, the same labels again] spec: containers: - name: main image: registry.example.com/orders-data-fix:2.0.1 [… omitted: the container's CPU and memory requests and limits] restartPolicy: NeverUn CronJob ha bisogno di una programmazione, e 0 0 30 2 * indica il 30 febbraio, una data che nessun anno contiene: sospeso, il CronJob non avvia alcuna esecuzione, e una volta ripreso non ha ancora alcun momento in cui avviarne una. Senza l’associazione un task senza programmazione sarebbe un Job, che viene eseguito non appena viene distribuito.
report è un CronJob secondo la programmazione che la Release ha soddisfatto, e non è sospeso:
[… omitted: apiVersion, kind and metadata, as in data-fix-cronjob.yaml under report's name]spec: schedule: 30 2 * * 1-5 jobTemplate: [… omitted: the job template, as in data-fix-cronjob.yaml with report's image]Un’esecuzione di data-fix è un Job creato dal suo CronJob, con un nome a tua scelta:
kubectl create job data-fix-run-1 --from=cronjob/data-fixLo stesso comando, con --from=cronjob/report, avvia un’esecuzione aggiuntiva di report tra quelle programmate.
Docker Compose
release-compose.yaml scrive un unico file Compose. Ogni task è un servizio che Compose non riavvia quando termina; data-fix porta anche il profilo manual, e report non ne porta alcuno:
services: data-fix: image: registry.example.com/orders-data-fix:2.0.1 [… omitted: the labels the build writes on every service, and the service's network] restart: "no" [… omitted: the CPU and memory limits and reservations] profiles: - manual report: image: registry.example.com/orders-report:1.4.2 [… omitted: the labels and the network, as on data-fix] restart: "no" [… omitted: the CPU and memory limits and reservations, as on data-fix][… omitted: the network the services join]Compose avvia un servizio che porta un profilo solo quando quel profilo è abilitato o il servizio è nominato sulla riga di comando, quindi docker compose up esegue report una volta e lascia data-fix fermo. Un’esecuzione di data-fix si avvia nominando il suo servizio, e --rm rimuove il suo container al termine dell’esecuzione:
docker compose -f dist/compose/docker-compose.yaml run --rm data-fixTerraform
release-terraform.yaml scrive una configurazione radice con un blocco di modulo per task, e accanto il modulo di ciascun task. I due blocchi differiscono nella programmazione:
# Root configuration for this boundary. Each component rendered here is one# module block below, and the directory that block points at holds that# component's own files. One configuration means one dependency graph, which is# what lets a reference or a depends_on reach from one component to another.
module "data-fix" { source = "./modules/data-fix"
assign_public_ip = false cluster = "arn:aws:ecs:eu-west-1:123456789012:cluster/example-cluster" cpu = "256" environment = {} execution_role_arn = "arn:aws:iam::123456789012:role/example-ecs-task-execution" image = "registry.example.com/orders-data-fix:2.0.1" memory = "512" name = "data-fix" security_groups = ["sg-0fedcba9876543210"] subnet_ids = ["subnet-0123456789abcdef0"]}
module "report" { source = "./modules/report"
assign_public_ip = false cluster = "arn:aws:ecs:eu-west-1:123456789012:cluster/example-cluster" cpu = "256" environment = {} execution_role_arn = "arn:aws:iam::123456789012:role/example-ecs-task-execution" image = "registry.example.com/orders-report:1.4.2" memory = "512" name = "report" schedule_expression = "cron(30 2 ? * 2,3,4,5,6 *)" schedule_expression_timezone = "UTC" scheduler_role_arn = "arn:aws:iam::123456789012:role/example-scheduler" security_groups = ["sg-0fedcba9876543210"] subnet_ids = ["subnet-0123456789abcdef0"]}Il modulo dichiara la programmazione di EventBridge Scheduler solo finché riceve un’espressione, quindi la definizione del task di data-fix resta a sé stante:
[… omitted: the provider requirement, the Region lookup, the task definition and the comments on each]resource "aws_scheduler_schedule" "this" { count = var.schedule_expression == null ? 0 : 1[… omitted: the rest of the schedule]La Recipe scrive la programmazione di report nella forma propria di EventBridge Scheduler: 30 2 * * 1-5 diventa cron(30 2 ? * 2,3,4,5,6 *), con i giorni della settimana numerati a partire dalla domenica come 1, in UTC perché la Release non nomina alcun fuso orario.
CloudFormation
release-cloudformation.yaml scrive un unico template dello stack. Contiene una definizione del task per ciascun task e una programmazione solo per report:
{ "AWSTemplateFormatVersion": "2010-09-09", "Resources": { "DataFixTaskDefinition": { [… omitted: the provenance metadata the build writes on every resource] "Properties": { "ContainerDefinitions": [ { "Essential": true, "Image": "registry.example.com/orders-data-fix:2.0.1", "Name": "main" } ], "Cpu": "256", "ExecutionRoleArn": "arn:aws:iam::123456789012:role/example-ecs-task-execution", "Family": "data-fix", "Memory": "512", "NetworkMode": "awsvpc", "RequiresCompatibilities": [ "FARGATE" ] }, "Type": "AWS::ECS::TaskDefinition" }, "ReportSchedule": { [… omitted: the provenance metadata] "Properties": { "FlexibleTimeWindow": { "Mode": "OFF" }, "ScheduleExpression": "cron(30 2 ? * 2,3,4,5,6 *)", "ScheduleExpressionTimezone": "UTC", "Target": { "Arn": "arn:aws:ecs:eu-west-1:123456789012:cluster/example-cluster", "EcsParameters": { [… omitted: the launch type, the network configuration and the task count each run starts with] "TaskDefinitionArn": { "Ref": "ReportTaskDefinition" } }, "RoleArn": "arn:aws:iam::123456789012:role/example-scheduler" } }, "Type": "AWS::Scheduler::Schedule" }, "ReportTaskDefinition": { [… omitted: the same shape as DataFixTaskDefinition, with report's image and family] } }}Nulla nello stack fa riferimento a DataFixTaskDefinition, quindi nulla la avvia.
Avviare un’esecuzione su Amazon ECS
Su entrambi i target AWS un’esecuzione di data-fix si avvia con l’operazione RunTask di Amazon ECS, a cui si passano la famiglia della definizione del task così come è stata renderizzata e la configurazione di cluster e di rete che la Release nomina sotto infra.overrides:
aws ecs run-task \ --cluster arn:aws:ecs:eu-west-1:123456789012:cluster/example-cluster \ --task-definition data-fix \ --launch-type FARGATE \ --network-configuration 'awsvpcConfiguration={subnets=[subnet-0123456789abcdef0],securityGroups=[sg-0fedcba9876543210],assignPublicIp=DISABLED}'Nominata solo dalla sua famiglia, la definizione del task si risolve nella sua revisione attiva più recente.
Che cosa non fa il build
La build scrive file e si ferma. Non avvia alcuna esecuzione, su nessun target: non raggiunge alcun cluster, non avvia alcuno stack Compose e non chiama alcuna API AWS, e l’associazione cambia solo ciò che dicono i file. Non scrive nemmeno alcuno script: ogni comando di questa pagina è quello proprio del target, eseguito da chi lo gestisce, e nessuno si trova in dist/. Le realizzazioni dell’associazione non aggiungono alcun file proprio su nessun target; la modifica che ciascuna apporta è nell’output proprio del task, mostrato sopra.
Le due Releases che si arrestano
release-compose-scheduled.yaml soddisfa report_schedule su Docker Compose, e associa anche core/manual-trigger a report. Su Kubernetes e AWS un task con una programmazione viene eseguito secondo quella programmazione, che l’associazione ci sia o no; su Docker Compose, senza scheduler, un task con una programmazione non ha alcuna realizzazione, associato o no. aggrega build --release release-compose-scheduled.yaml --auto-pull si arresta:
[… omitted: what resolving the lockfile prints, the same halt among it][CATALOG_ERROR E0033] Recipe/FeatureRecipe assertions caused by: Recipe "task" instance "report" assertion "schedule_refused": [… omitted: the template position and the assertion's own source]: error calling fail: assertion failed: the component "report" is scheduled "30 2 * * 1-5", and Docker Compose has no scheduler: nothing in a compose file starts a service at a time, so the run would happen at none of the times written. Map core/compute/task to helm/task in the Manifest, which runs it on its schedule as a Kubernetes CronJob; or remove the schedule from the component in the Aggregate to run it once at each docker compose up, or attach core/manual-trigger to it there to start each run with docker compose run --rmrelease-terraform-unscheduled.yaml lascia vuoto report_schedule su Terraform, quindi report non ha né una programmazione né l’associazione, e nulla su AWS lo avvierebbe mai. È il caso per cui esiste core/manual-trigger, e aggrega build --release release-terraform-unscheduled.yaml --auto-pull si arresta nominandola:
[… omitted: what resolving the lockfile prints, the same halt among it][CATALOG_ERROR E0033] Recipe/FeatureRecipe assertions caused by: Recipe "task-ecs" instance "report" assertion "schedule_translates": [… omitted: the template position and the assertion's own source]: error calling fail: assertion failed: the component "report" has no schedule and carries no core/manual-trigger attachment, so it runs once, and nothing on AWS starts a run that happens once: neither Terraform nor CloudFormation runs an Amazon ECS task when it applies, so the run would never happen. Give the component a schedule in the Aggregate; attach core/manual-trigger to it there to deploy its task definition alone, for the operator to start each run with aws ecs run-task; or map core/compute/task to helm/task in the Manifest, which runs it once on KubernetesQui la programmazione raggiunge il task tramite un parametro che la Release soddisfa, quindi dare una programmazione al componente significa soddisfare report_schedule, come fa release-terraform.yaml.