* refactor: move telemetry file naming to contract
* docs: record telemetry contract move
* refactor: move aws xml response helpers
* docs: record aws xml helper move
* refactor: move aws tag projections to foundation
* docs: record aws tag projection move
* refactor: move account key to state foundation
* docs: record account key state move
* refactor: move host privilege escalation to runtime
* docs: record host privilege move
* chore: resolve lint findings from package-boundary moves
* refactor: move process supervision helpers to runtime host
* docs: record process supervision move
* refactor: move nbd endpoint helpers to compute runtime
* docs: record nbd endpoint move
* refactor: move image catalogue to operator
* docs: record image catalogue move
* refactor: move resource id generation to aws foundation
* docs: record resource id move
* refactor: move predastore role to runtime roles
* docs: point service manifest at acm domain
* docs: record predastore role move
* refactor: move northstar role to runtime roles
* docs: record northstar role move
* refactor: move awsgw role to runtime roles
* docs: record awsgw role move
* refactor: move error payload helpers to aws errors
* docs: record error payload move
* refactor: move account identifiers to aws identifiers
* docs: record account identifier move
* refactor: move NATS transport to messaging foundation
* docs: record NATS transport move
* refactor: move system instance contract to EC2 domain
* docs: record system instance move
* refactor: move system VPC builder to network domain
* docs: record system VPC move
* refactor: move instance metadata service to EC2 domain
* docs: record guest metadata move and dependency-rule debt
* refactor: move DNS control plane to DNS domain
* docs: record DNS domain move
* refactor: move base zone bootstrap to DNS domain
* docs: record base zone bootstrap move
* refactor: replace SystemAccountID with GlobalAccountID
* docs: record SystemAccountID removal
* refactor: extract CA key-pair loader to foundation pki
* docs: record foundation pki extraction
* refactor: move tenant CA paths to ACM domain
* docs: record tenant CA path move
* refactor: move IPsec certificate handling to network host
* docs: record IPsec certificate move
* refactor: move Ochre serving lifecycle to the Ochre domain
handlers/bedrock becomes domains/ochre. Ochre is the platform service;
Bedrock names only its AWS API surface. Persisted and observable
identifiers keep their bedrock names.
* docs: record Ochre domain move
* refactor: move Ochre vector store to the Ochre domain
handlers/ochrevector becomes domains/ochre/vector. Callers import it as
ochrevector because vector is a common local name in the gateway.
* docs: record Ochre vector store move
* refactor: move Hugging Face Hub client to the Ochre domain
gateway/bedrock/hfhub becomes domains/ochre/hfhub. Its only caller is
the spx admin ochre weights pull.
* docs: record Hugging Face Hub client move and Ochre gateway debt
* refactor: move EC2 tag mutation helpers to the EC2 domain
utils/tagmirror.go becomes domains/ec2/tagmirror. It is EC2-wide tag
mutation behaviour, and the tags resource package cannot host it
without a resource-to-resource import cycle.
* docs: record EC2 tag mutation move and migrate split finding
* refactor: move network packages under the network domain
Move spinifex/network/* to spinifex/domains/network/* as one enclosing
move so the L0-L5 layer invariants keep classifying every package from
a single root. Package names and dependency direction are unchanged;
invariant scan roots, the RG-10 sudo allow-list path, CODEOWNERS and
the repo-root walk in the IMDS netns unit test follow the new path.
* docs: record network domain move
* refactor: move standalone EC2 resource packages to the EC2 domain
Move handlers/ec2/{account,key,launchtemplate,placementgroup,
spotinstance,volumestate} to domains/ec2/<resource>. Each package is
named after its directory and callers import it as ec2<resource>;
volumestate already carried its directory name.
* docs: record standalone EC2 resource moves
* refactor: move EC2 VPC networking packages to the EC2 domain
Move handlers/ec2/{vpc,eigw,eip,igw,natgw,routetable} to
domains/ec2/<resource>, each named after its directory and imported as
ec2<resource>. The reconcile drift-watch source scan now matches the
ec2<resource> bucket qualifiers; its rule is unchanged.
* docs: record EC2 VPC networking moves
* refactor: move EC2 compute and storage packages to the EC2 domain
Move handlers/ec2/{instance,volume,snapshot,image,tags} to
domains/ec2/<resource>, each named after its directory and imported as
ec2<resource>, which empties handlers/ec2. The daemon's e2e suite
selection now lists the moved EC2 resource paths in place of
handlers/ec2, so EC2-only changes select the daemon suites again.
* docs: record EC2 compute and storage moves
* refactor: move ECR credential provider to the EKS agent tree
Move the kubelet exec credential provider implementation from
cmd/ecr-credential-provider to agents/eks/credentialprovider, exposing
one Main(in, out) entry point. The binary keeps its name and FIPS boot
import as a thin main. Moving out of cmd/ brings the code under gosec;
the one G101 hit on the kubelet API version constant is annotated.
* docs: record ECR credential provider move
* refactor: move EKS gateway publish helper to the EKS agent tree
Move the eks-gateway-publish implementation to agents/eks/gatewaypublish
behind Run(ctx, Config) error. The binary keeps flag definitions,
environment defaults, parsing, its log prefix and exit code; each former
fatal site returns an error with the same text. The retry wait now also
honours context cancellation, which the binary never triggers.
* docs: record EKS gateway publish move
* refactor: move EKS gateway fetch helper to the EKS agent tree
Move the eks-gateway-fetch implementation to agents/eks/gatewayfetch
behind Run(ctx, Config) error, writing its TSV to Config.Out. The binary
keeps flag definitions, environment defaults, parsing, its log prefix and
exit code; each former fatal site returns an error with the same text.
* docs: record EKS gateway fetch move
* refactor: move EKS webhook cert helper to the EKS agent tree
cmd/eks-webhook-cert keeps flag parsing, the log prefix and the exit;
agents/eks/webhookcert owns Config and Run. Output, error text, file
modes and exit codes are unchanged.
* docs: record EKS webhook cert move
* refactor: move EKS konnectivity cert helper to the EKS agent tree
cmd/eks-konnectivity-cert keeps flag parsing, the log prefix and the
exit; agents/eks/konnectivitycert owns Config and Run. Output, error
text, file modes and exit codes are unchanged.
* docs: record EKS konnectivity cert move
* refactor: move EKS token webhook to the EKS agent tree
cmd/eks-token-webhook keeps the -addr flag, environment-derived
config, logging setup and exits; agents/eks/tokenwebhook owns Config
and Run. The handlers/eks TokenReview result type stays as recorded
temporary debt.
* docs: record EKS token webhook move
* refactor: move ECS agent runtime and credentials packages to the ECS agent tree
* docs: record ECS agent subpackage move
* refactor: move ECS agent implementation to the ECS agent tree
cmd/ecs-agent keeps process lifecycle: signal context, the separate New
and Run calls, both failure log lines, the exit and the ldflags-set
build version, now passed in through Config.AgentVersion.
agents/ecs/agent owns Config, LoadConfig and the agent.
* docs: record ECS agent move
* refactor: move RDS guest agent to agents/rds/agent
* docs: record RDS guest agent move
* refactor: move installer packages to operator/installer
* docs: record installer move
* refactor: move spx command tree to operator/cli
Moving the command tree out of cmd/ brings it under errcheck and gosec.
Flag and config wiring now fails loudly instead of silently dropping a
binding, listing commands fail when they cannot write their table, and
the formation server's unauthenticated TLS is annotated as a known gap.
* docs: record spx command tree move
* chore: accept known vulnerabilities with an expiry
The vulnerability scan failed preflight on a containerd advisory that dev
already carries and that is deferred to a separate dependency update. The
gate now passes only reachable findings listed with an expiry date, fails
on any new one or on an expired acceptance, and warns when an acceptance
is no longer needed.
* refactor: move EC2 account action adapters to domains/ec2/awsapi
* refactor: move EC2 capacityreservation action adapters to domains/ec2/awsapi
* refactor: move EC2 key action adapters to domains/ec2/awsapi
* refactor: move EC2 launchtemplate action adapters to domains/ec2/awsapi
* refactor: move EC2 placementgroup action adapters to domains/ec2/awsapi
* docs: record EC2 standalone action adapter moves
* refactor: move EC2 zone action adapters to domains/ec2/awsapi
* refactor: move EC2 vpc action adapters to domains/ec2/awsapi
* refactor: move EC2 eigw action adapters to domains/ec2/awsapi
* refactor: move EC2 eip action adapters to domains/ec2/awsapi
* refactor: move EC2 igw action adapters to domains/ec2/awsapi
* refactor: move EC2 natgw action adapters to domains/ec2/awsapi
* refactor: move EC2 routetable action adapters to domains/ec2/awsapi
* docs: record EC2 VPC networking action adapter moves
* refactor: move EC2 image action adapters to domains/ec2/awsapi
* refactor: move EC2 snapshot action adapters to domains/ec2/awsapi
* refactor: move EC2 volume action adapters to domains/ec2/awsapi
* refactor: move EC2 tags action adapters to domains/ec2/awsapi
* docs: record EC2 storage and tag action adapter moves
* refactor: move EC2 resource authorization scopes to domains/ec2/awsapi
* refactor: move EC2 idempotency adapter to domains/ec2/awsapi
* refactor: move EC2 instance action adapters to domains/ec2/awsapi
* refactor: move EC2 spotinstance action adapters to domains/ec2/awsapi
* docs: record EC2 instance action adapter moves
* refactor: move AWS REST-JSON router to ingress/aws/rest
* refactor: move SigV4 auth-failure rate limiter to ingress/aws/ratelimit
* docs: record AWS ingress helper moves and tooling conformance
* docs: correct historical lifecycle references
* test: characterize ECR control-plane dispatch before registration seam
* feat: add AWS ingress service registration contract
* docs: record ingress registration phases 0 and 1
* refactor: route registered AWS services through the ingress dispatch registry
The gateway now consumes ingress/aws/dispatch. A registered service is
accepted by the auth gate, resolves its own action label, renders errors in
its declared envelope and is dispatched with an authenticated Invocation
(account, region, policy authorisation and a lazy verified actor). Every
other service keeps the existing switch, now named as the legacy path.
The awsgw role wires an empty registry and refuses to start if a registered
name is also served by the legacy table. No service is registered yet, so
behaviour for every existing service is unchanged.
* docs: record ingress dispatch registry consumption
* refactor: register the ECR control plane from its domain
domains/ecr/awsapi now registers the "ecr" AWS JSON 1.1 surface with the
ingress dispatch registry: action resolution, resource scope, authorisation
through the invocation, the composed capabilities and the success writer all
live with the domain. The awsgw role is the only serving composition point;
the gateway no longer imports the ECR API package and ECR leaves the legacy
service table, JSON error table and dispatch switch. The OCI /v2 route is
unchanged.
Operation coverage reads ECR's declared inventory, which the registration
uses verbatim; coverage.json is byte-identical.
* docs: record ECR control-plane registration
* fix: compose the ECR control plane in the integration harness
The harness stopped wiring ECR's composed capabilities when the
authorization-token action was composed, so every integration test that
creates a repository or mints a token got ServerInternal. It now composes
ECR as the awsgw role does, sharing the OCI registry, meta store and token
issuer the /v2 data plane uses.
* docs: record ingress pipeline deferral
* refactor: extract AWS error envelope rendering to ingress
ingress/aws/envelope owns the EC2, IAM-style and S3 XML error envelopes, the
AWS JSON 1.1 error body and X-Amzn-Errortype value, the JSON-protocol header
detector and the two error content types. Each shape keeps its own builder.
The gateway error writers, ErrorHandler and the legacy per-service envelope
selection stay in gateway and call the new package; gateway/eks renders its
JSON errors through it directly. A 140-case status/header/body golden
comparison across services and error writers was identical before and after.
* docs: record error envelope extraction
* refactor: move AWS service selection into ingress dispatch
Selector answers served, action, error protocol, registered entry and
startup overlap. The gateway supplies its legacy tables through the
dispatch.Legacy interface; legacy dispatch and invocation building stay
in gateway.
* docs: record ingress service selection move
* test: characterize ACM control-plane dispatch before registration
Pins full-pipeline error envelopes, a successful action, target parsing
agreement between dispatch and telemetry, authorization before the NATS
call, 413 and 503 paths, throttle/trace/audit action and the inventory.
* refactor: register ACM control plane from its domain
domains/acm/awsapi registers the acm JSON 1.1 surface through the
ingress dispatch registry, wired by the awsgw role. The gateway drops
ACM_Request, the ACM action table and every legacy acm entry; the
import invariant now covers each registered domain.
* docs: record ACM registration
* docs: record ECS, EKS and RDS source inventory and first-resource ranking
* docs: record EKS control-plane secrets persisted in the cluster record
* chore: drop containerd advisory acceptance now that dev ships v2.4.1
* test: characterize RDS DB subnet group lifecycle before extraction
* docs: record RDS DB subnet group lifecycle contract
* refactor: extract the RDS DB subnet group lifecycle owner
domains/rds/subnetgroup owns the db-subnet-groups/{name} record, member
subnet validation and the delete in-use guard. handlers/rds keeps AWS
validation, projection and paging and binds two consumer-owned
capabilities: the owner's Dependants (instances naming the group) and the
instance side's subnetGroupPlacement. Stored shape and behaviour are
unchanged.
* docs: record RDS DB subnet group owner extraction
* docs: correct RDS subnet group tagging debt and conformance scope
* test: characterize ECS task definition lifecycle before extraction
* docs: record ECS task definition lifecycle contract
* refactor: extract ECS task definition owner into domains/ecs/taskdefinition
Move the task definition record, container types, keys, reference parsing,
ARN helpers and the register/deregister/resolve/list logic into a resource
owner package. Stored JSON field names and KV keys are unchanged, and
revision allocation keeps its existing non-atomic read-then-write.
The owner declares its own PortMapping and SystemControl persisted types so
it no longer depends on handlers/ecs/bus; the handler translates them onto
the assign payload. Task and service launches reach task definitions only
through a launch-side taskDefinitionResolver. AWS conversion, the guest
projection and tags stay in handlers/ecs, and gateway authz only switches to
the moved reference/ARN helpers.
List handlers/ecs and the new package under spinifex_daemon so ECS-only
changes select e2e-ecs.
* docs: record ECS task definition owner extraction
* test: characterize EKS access entry lifecycle before extraction
* docs: record EKS access entry lifecycle contract
* refactor: extract EKS access entry owner into domains/eks/access
Move the access entry record, associated policy and scope types, keys,
PrincipalARNHash, the policy catalogue and group mapping into a resource
owner package. Stored JSON field names and KV keys are unchanged.
Owner is the only writer: Create, SeedCreatorAdmin, Update, Associate,
Disassociate and Delete carry the existing logic verbatim, and the put,
compare-and-set and delete primitives are private. The handler keeps AWS
validation, the cluster existence check, error mapping and projection.
Token review still reads records through the exported Get, and the cluster
prefix purge still sweeps entry keys.
List handlers/eks and the new package under spinifex_daemon so EKS-only
changes select the EKS suites.
* docs: record EKS access entry owner extraction
* test: characterize RDS engine catalogue before extraction
* fix: return InvalidParameterValue for a missing RDS master password
ValidateMasterUserPassword built the empty-password error with a bare
errors.New carrying the code only in its text, which awserrors does not
resolve, so CreateDBInstance without MasterUserPassword returned HTTP 500
ServerInternal. Build it with awserrors.Errorf like the other branches so
the gateway returns 400 InvalidParameterValue, and cover the full gateway
to RDS service path with a regression test.
* docs: record RDS engine catalogue boundary and evidence
* refactor: extract RDS engine catalogue into domains/rds/engine
Move engine identity and validation, the per-engine parameter catalogues,
effective-parameter resolution, db.* instance classes and engine/orderable
selection into an engine package. Behaviour, error codes and ordering are
unchanged.
The package imports no EC2 package: instance-class memory comes from an
immutable Sizing value built from an engine-declared InstanceTypes
interface, backed by the fixed instance-type table in handlers/rds.
Effective parameters leave as an engine-owned Setting, converted to
Parameter in handlers/rds. AWS output building, paging, apply-method
mapping, storage limits and the gateway runnable check stay in the
adapter path.
The RDS agent declares its own EngineCatalog interface and types and
receives an engine-backed implementation from cmd/rds-agent, so agent
code does not import the catalogue. Cross-engine tests use the two real
engines instead of a registered fake.
* docs: record RDS engine catalogue owner move
* test: characterize RDS DB parameter group lifecycle before extraction
* docs: record RDS DB parameter group lifecycle contract
* refactor: extract RDS DB parameter group owner
Move the parameter group and override records, keys and listing into
domains/rds/parametergroup behind an Owner. Delete asks an owner-declared
Dependants interface; instance-side resolution reads through its own
parameterGroupValues interface. SetOverrides refuses an unknown group so
no override key is written without its group. Stored shape, keys, public
errors and propagation are unchanged.
* docs: record RDS DB parameter group owner extraction
* test: characterize EKS add-on lifecycle and guest wire
Pin the persisted record and manifest layout, create/update/delete and
status-report transitions, the ignored client token and report version,
the missing serviceAccountRoleArn PassRole check, and the exact internal
add-ons HTTP body and agent TSV output as they stand today.
* docs: record EKS add-on lifecycle contract
* fix: require iam:PassRole for EKS add-on service account role
CreateAddon and UpdateAddon now pass serviceAccountRoleArn through the
existing EKS PassedRoleARNs path, so the caller needs iam:PassRole on the
role for eks.amazonaws.com, matching CreateCluster and CreateNodegroup.
* docs: record EKS add-on PassRole check
* refactor: extract EKS add-on owner
Move the add-on catalogue, record and manifest keys, CAS, status
transitions and staging into domains/eks/addon behind an Owner that is
the sole writer. The handler keeps AWS validation, error mapping and
projection; the cluster reconciler delegates reports through the narrow
addonReports interface; node groups call EnsureGPUDevicePlugin. Stored
keys, JSON shape, wire types and lifecycle behaviour are unchanged.
* docs: record EKS add-on owner extraction
* refactor: extract EKS add-on guest wire contract
Move the add-on status subject, delivery phase, status report, staged
manifest and internal add-ons response into contracts/eks/v1 and use it
from the handler, gateway and gatewayfetch, replacing the agent's
duplicate. Wire bytes are unchanged, including the internal add-ons body
that the SDK renderer emits with Go field names; compatibility tests pin
the JSON, the guest printf form and the TSV.
* docs: record EKS add-on wire contract extraction
* docs: update EKS add-on inventory and remaining edges
* docs: draft EKS add-on lifecycle correction design for review
* chore: run contracts tests in the default test, coverage and race targets
* docs: apply review decisions to EKS add-on lifecycle design
* test: characterize EKS add-on v1 compatibility with added fields
Pin which owner writes drop unknown record and manifest fields, that
reads and deletes ignore or erase them, that one undecodable entry fails
a listing, and that v1 wire consumers ignore extra fields.
* docs: add EKS add-on executor, bundle, v1 compatibility and release inventories
* docs: draft EKS add-on v2 guest contract design for review
* docs: qualify historical architecture references
* docs: apply review decisions and ADR-0006 to EKS add-on v2 design
* fix(eks): bind internal report publishing to the caller's cluster
PublishInternal was authorised by IAM policy alone, with its resource
built from the body accountId and the URL cluster. The control-plane
role grants it on "*", so any control-plane VM session, any tenant
holding eks:*, or static system credentials could publish cluster
state, bootstrap and add-on reports for another cluster or account.
PublishInternal now passes the existing internal-route gate: the caller
must be a control-plane instance-role session that is a member of the
URL cluster in the body account. The gate and the handler decode the
body through one shared decoder, so the account checked is the account
the subject is built from. Every unauthorised target returns the same
AccessDenied, and invalid account or cluster names are treated as not
found. Valid publishes keep their subjects and payload bytes.
* fix(eks): bind webhook token review to the caller's cluster
WebhookTokenReview took its account from the request body and was
authorised by IAM policy alone, with the control-plane role granting it
on "*". A control-plane VM, any tenant holding eks:*, or static system
credentials could resolve a token against another cluster or account
and learn the Kubernetes groups it maps to there. Error responses also
distinguished absent accounts from absent clusters.
WebhookTokenReview now passes the same internal-route gate as
PublishInternal: a control-plane instance-role session that is a member
of the URL cluster in the body account. The gate and the handler share
one body decoder, each body-scoped internal route must declare its
reader, and every unauthorised target returns the same AccessDenied
without reaching STS verification. Same-cluster responses are unchanged.
* fix(eks): validate add-on serviceAccountRoleArn syntax
CreateAddon and UpdateAddon stored serviceAccountRoleArn without
checking it was an ARN, and the guest renders the value into the
add-on's manifests. A non-empty value must now be syntactically an IAM
role ARN (12-digit account, no region, role resource, IAM name and path
rules); anything else returns InvalidParameterException before any
record is written or manifest staged.
The syntax check is foundation/aws/arn.ValidateRoleARN. iam:PassRole at
the gateway remains the permission and existence check. Stored values
are not rewritten, and an UpdateAddon that omits the field still
succeeds on a record holding a legacy value.
* docs: record EKS internal-route and role-ARN security corrections
* docs: add EKS add-on release membership and activation case study
* fix: point UI build, CI and lint rules at moved package paths
* docs: record EKS add-on activation review decisions
* refactor: move quota admission to domains/admission/quota
Relocate the quota service, live counters and vCPU records from
handlers/quota to domains/admission/quota. Package renamed from
handlers_quota to quota; callers with a local quota identifier import it
as admissionquota. KV buckets, subjects and error codes are unchanged, and
the package's existing debt edges move with it unchanged.
* docs: reconcile package-boundary record for ADR-0001 close-out
Add the missing slice rows (the commits that dissolved spinifex/types, the
ECR repository projection, the stale-path fix and the quota move), correct
stale entries, record the dependency-rule breaks found in the import graph
with removal conditions, add the close-out table of remaining legacy paths
with their decided target owners, recount the mulga-side follow-ups, and
fix stale old-path references in docs and comments.
* test: move KV migration engine tests to foundation/state/migrate
The Registry and RunKV tests exercise foundation/state/migrate exclusively
but lived in spinifex/migrate's test file. Relocate them, with their NATS
helpers, to the package that owns the engine. No test name, assertion or
behaviour changes.
* refactor: move config and object-store upgrade workflow to operator/upgrade
Relocate spinifex/migrate, the operator-driven config-file and object-store
upgrade workflow behind spx admin upgrade, to operator/upgrade. Package
renamed to upgrade (imported as opupgrade where a local upgrade identifier
exists). It stays distinct from foundation/state/migrate, the generic KV
migration engine; no registry types, migration names, versions, file
formats or command names change.
* docs: record migrate move to operator/upgrade
* test: enforce ADR-0001 layering with a blocking ratchet
Add spinifex/architecture/layering, a test-only package that parses the
module's import graph, maps every production package to an ADR-0001
layer and checks each dependency rule as its own subtest. Existing
violations are allow-listed against their recorded debt; a new forbidden
edge, an unmapped package, a stale allowlist entry or a new package
under a frozen legacy root fails local preflight and CI.
Record the nine edges the test found missing from the migration record
(quota -> EC2 instance types, STS/Ochre/ELBv2 -> IAM, ELBv2
cross-domain, installer UI -> admin), name the importers of the utils
residuals and gateway/ec2_idempotency.go, and correct the handlers/iam
consumer list.
* refactor: drop the legacy handlers_ecr import alias
Import domains/ecr under its package name, or as ecrdomain where the
file also imports the AWS SDK ecr package, matching acmdomain. Also fix
a stale daemon file reference in the integration ECR daemon comment.
* chore: mark spf13/pflag as a direct dependency
operator/cli/wiring.go imports pflag directly. Same version; no upgrade.
* docs: record test-package-check and nilaway as unverified gates
* refactor: move the layering test to module-root architecture/
The ADR-0001 layering ratchet is repository governance tooling, not
Spinifex product code, so it sits beside tests/ rather than under the
spinifex/ product tree. make test, test-cover and test-race now include
./architecture/..., and the graph walk excludes architecture/.
* fix: update paths left stale by the package moves
The MariaDB image stamp test read the RDS engine from
handlers/rds/engine_mariadb.go, so test-images failed in CI; it now reads
domains/rds/engine/mariadb.go. Comments citing moved files now name
their new locations.
* refactor: move the default-VPC subject into contracts/ec2/v1
utils.SubjectEnsureDefaultVpc becomes ec2v1.EnsureDefaultVpcSubject, the
request/reply route between gateway account creation and the daemon.
Only the subject moves; the request and reply bodies are still anonymous
structs on each side and are recorded as such in the contract README.
The layering freeze now allows two utils files.
* docs: qualify the migrate split and record admin and Viperblock findings
The migrate row is a split, not an exact ADR-0001 map row, and needs a map
clarification. Correct the stale admin consumers, record the operator-only
admin files as movable, the vbwire prerequisite for the Viperblock adapter
and the capability decision encryption.go needs.
* refactor: move operator-only admin code to operator/admin
Config generation, certificate issuance, host discovery, telemetry,
email validation and image import/removal/orphan-volume tooling move
to operator/admin. Legacy admin keeps only the symbols with
non-operator consumers: default account identifiers, AWS credential
generators and system image promotion.
foundation/pki and the tenant ACM CA are unchanged. The readAMI
helper and the removal test fixtures are duplicated privately in
legacy admin rather than shared across the split. The now-stale
operator/installer/ui -> admin layering allowlist entry is removed.
* docs: record operator/admin split in package-boundary migration
* test: pin viperblockd fence, abandon and dirty-marker wire shapes
Characterization tests against the current vbwire package, before it
moves to contracts/viperblockd/legacy/v1: both subject forms for the
fenced and abandon routes, golden JSON for VolumeFencedEvent,
VolumeAbandonRequest, VolumeAbandonResponse and DirtyRecord, the dirty
bucket name, and the volume-key pattern shared by the lease and dirty
stores.
* refactor: move viperblockd fence, abandon and dirty-marker vocabulary to contracts
Move the fence and abandon subjects/DTOs, the dirty bucket name,
DirtyRecord and the shared volume-key pattern out of vbwire and into
contracts/viperblockd/legacy/v1, alongside the package's existing
mount/unmount/delete/sync/config-update routes. vbwire keeps only the
I/O helpers (BindDirtyBucket, ListUnsealedVolumes), now built on the
contract vocabulary instead of defining it.
Record the approved dirty-marker ownership boundary in the contract
README: the Viperblock adapter is the sole producer, viperblockd was
only its transitional custodian. Document the fence and abandon routes
and the dirty bucket in docs/service-interfaces.yaml.
* refactor: split the Viperblock EBS adapter out of services/viperblockd
Move the EBS provider adapter (volume lease, fence, dirty marker,
nbdkit recovery, provider handlers, encryption key loading) to
providers/ebs/viperblock. services/viperblockd keeps only process
lifecycle and the NATS subscription wiring that starts and stops it.
The dirty-bucket read path moves to providers/ebs/viperblock/dirty as
a read-only ListUnsealedVolumes capability; the adapter's write, clear
and purge logic stays unexported in the adapter package. Delete
services/viperblockd/vbwire now that its vocabulary lives in
contracts/viperblockd/legacy/v1 and its I/O helpers live in dirty.
Update operator/cli, the runtime service registry, qemunbdd's config
comment and the integration test harness to the new import paths, and
drop the now-stale architecture/layering allowlist and frozen-package
entries for the deleted package. Behaviour, persisted keys and NATS
subjects are unchanged.
* refactor: move the viperblockd role to runtime/roles/viperblockd
With the EBS adapter in providers/ebs/viperblock, services/viperblockd
holds only role supervision and the opt-in live data-path tests, so it
joins the other runtime roles. It was the last package under services/;
the frozen legacy list drops it.
* docs: record viperblockd contract, adapter and role moves
* test: characterise vpc.* network-realisation routes
Pin every vpc.* subject, JSON payload shape and the request/reply
{success,error} ack envelope exactly as they exist today, ahead of
introducing contracts/network/v1. Covers the 22 subjects registered
by domains/network/subscribers, the vpc.igw-attach/detach subjects
and InternetGatewayEvent already owned by contracts/ec2/v1, the
utils.AddNAT/PublishNATEvent client wire behaviour including the
delete-nat retry-on-ErrNoResponders budget, and the EC2-side NATEvent
and SGEvent/SGRule duplicates in domains/ec2/vpc.
Also adds the six vpc.* route-table and system-egress subjects that
were missing from service-interfaces.yaml despite being live
production routes (vpc.add/delete-igw-route, vpc.gate/ungate-subnet-
egress, vpc.add/delete-system-egress).
* feat: add contracts/network/v1 for vpc.* realisation routes
Declare the versioned wire vocabulary for the vpc.* control-plane-to-
network-realisation boundary: subjects, payload types, the shared
{success,error} ack envelope and the vpcd-workers queue group, one
file per route family. No NATS I/O, no consumer switched over yet;
the package coexists with the fragmented originals pinned in the
prior characterization commit until slice 3 migrates call sites.
* refactor: use contracts/network/v1 for vpc.* producers and consumers
Switch every vpc.* producer (domains/ec2/vpc, eip, instance, natgw,
routetable, igw, handlers/elbv2, handlers/eks, daemon, systemvpc) and the
network/subscribers consumer onto contracts/network/v1 subjects, event
types and the shared AckEnvelope. contracts/network/v1 becomes the sole
owner of vpc.igw-attach/detach, replacing the duplicate definitions in
contracts/ec2/v1.
Deletes the duplicated local subject constants and event structs:
subscribers' Topic* consts and event structs, vpc.NATEvent and SGEvent,
eip's natEvent, natgw's natGatewayEvent, and eks's systemEgressEvent.
domains/ec2/vpc.SGRule survives because EC2 persists it directly in
SecurityGroupRecord; contracts/network/v1.SecurityGroupRule was expanded
in slice 2 to match it field-for-field so wire bytes are unchanged.
No lifecycle or reliability changes: the NAT add barrier, delete
retry-on-ErrNoResponders, and the inconsistent per-call-site NAT
delivery modes (EIP AssociateAddress and DeleteNetworkInterface both stay
fire-and-forget with no ack) are preserved exactly, as are the golden
wire literals pinned in the characterization tests.
* refactor: replace utils/vpcd_event.go with a typed network projection client
Every vpc.* call site now goes through domains/network/projection's
operation-specific methods instead of utils.AddNAT, utils.PublishNATEvent
or utils.RequestEvent, so no caller passes a bare subject string. Each
method states today's delivery mode by name: AddNAT stays strict,
AddNATBestEffort and AnnounceNATAdd/AnnounceNATDelete keep the gaps those
call sites already had, and RemoveNAT keeps the ErrNoResponders retry.
utils/vpcd_event.go and its tests are deleted; the behaviour they pinned
(wire shape, ack envelope, retry-on-no-responders) moved into the
projection package's own golden and nat tests, unchanged. utils/ now
holds only encryption.go, which this does not touch.
* refactor: route the remaining fire-and-forget vpc.* producers through projection
CreateVPC/DeleteVPC, CreateSubnet/DeleteSubnet, AttachInternetGateway/
DetachInternetGateway, AddNATGateway/RemoveNATGateway, AddIGWRoute/
RemoveIGWRoute, GateSubnetEgress/UngateSubnetEgress and RemoveSystemEgress
were still publishing through natsmsg.PublishEvent or a raw nc.Publish
call with a bare subject string, left over from the mechanical slice 3
pass. Each now goes through its named projection.Client method instead,
so every vpc.* producer in the tree uses the typed client.
* refactor: move EBS encryption posture to domains/ec2/ebs/encryption and delete utils
The master-key loader was used only by EC2 image, instance and volume to
derive the AWS-visible Encrypted flag. It becomes ebsencryption.Enabled,
EC2's temporary reading of the provider's key-file setting; the cache,
empty-path meaning, error text and each caller's error handling are
unchanged (image still reports unencrypted when the key will not load).
Its successor is a providers/ebs capability reporting volume encryption
posture.
utils/ is now empty and deleted. The layering test drops utils and
services from the legacy roots, removes their allowlist entries and fails
if either retired root regains files. The S7 subject scan follows the
vpc.* literals from utils to contracts/network so its gap list stays
complete.
* docs: record the network contract, projection client and utils removal
* test: characterise instance-state persistence, recovery and generation handling
Pin the current local-file bytes and schema failure modes, the instance
bucket configuration, record key and wire form, the bucket version gate,
generation preservation across every KV writer and the VM conversion, and
what a returning node does for a missing, foreign, terminal or unreadable
canonical record. These describe current behaviour, not the ADR-0007 target.
* test: freeze direct instance-state consumers
Add an AST ratchet over production code that fails when a new file names
the daemon's instance-state bucket, record keys, local-file API, the raw
vm.InstanceRecord or its conversion, or a JetStreamManager instance-state
method. Today's 73 uses form a shrink-only allowlist keyed to the slice 0
inventory; stale entries fail, and a synthetic-source self-test proves the
matcher detects each kind of use and ignores declarations.
* docs: record ADR-0007 slice 0 instance-state inventory
Record the instance-state persistence formats, the nineteen direct
consumers by process and access kind, the characterised recovery and
schema outcomes, the generation-preservation matrix and the ratchet that
freezes the consumer set. Nothing conforms to ADR-0007 yet and vpcd stays
blocked.
* test: narrow the instance-state ratchet to instance-state access
Stop freezing the JetStreamManager type and constructor, which also serve
cluster state; flag only instance-state methods, bucket and key identifiers,
record codecs and local-state access. The cluster-state-only consumers in
daemon_mgmt_ip.go and operator/cli/cluster.go leave the allowlist (73 to 67).
The self-test now proves a cluster-state use is ignored and an instance-state
method call is caught. Record the owner's disposition of the KV-unavailable
restore result in the migration record.
* docs: record the narrowed instance-state ratchet commit
* docs: design the instance-state transition record and activation gate
* docs: record the instance-state transition-record design commit
* docs: record slice 1a activation-gate decisions
* feat: add instance transition-record codec with format marker
Adds DecodeTransitionRecord and TransitionRecord.Encode in the record's owner
package. A top-level format member selects the shape: absent or 1 decodes the
legacy record and is never given a marker on write; 2 also decodes the new
assignment and observation sections; an integer above 2 decodes its legacy
fields read-only and Encode refuses it; anything else is refused on decode.
Encode applies only the typed paths that differ from the decode-time snapshot
onto the input, so unknown members at every object level and unchanged known
fields keep their read form. A changed array is replaced whole. Decode refuses
malformed JSON, duplicate keys at any depth, keys that alias a known field by
case, trailing data and a non-object record, each with its own sentinel.
No production reader or writer uses the codec yet; the new types are not
part of vm.InstanceRecord, so every existing record encodes unchanged. The
codec file is registered as an owner file of the instance-state ratchet.
* docs: record slice 1b step 1 codec and awsgw rollout qualification
Records the codec added in e62f921d2 as design Section 10 (C1 to C7): its
surface, preservation at every object level, the changed-array limitation,
marker handling, the rejection classes and its capable-writers-only scope. C2
supersedes P1's top-level-only preservation for the codec. G19 records that
old read-only gateway consumers remain safe but DescribeInstanceStatus gains
unconfirmed/degraded visibility only after awsgw upgrades. The migration record
gains the commit row and states that no production path uses the codec yet.
* refactor: move the instance transition-record codec to domains/ec2/instance/state
The codec defines how the canonical persisted instance record evolves, with
its assignment and observation sections, which is EC2 instance ownership rather
than node-local VM supervision. It moves unchanged into its own package and
keeps wrapping the legacy vm.InstanceRecord alias and its spec and status
types, which stay in runtime/compute/vm for now.
The domain-to-runtime import is recorded as new dependency-rule debt with its
removal condition and allow-listed against that entry. The instance-state
ratchet now names the new file as an owner file; its allowlist is unchanged.
* fix: refuse array changes that would drop element extensions
A changed array is replaced whole by the writer's value, which silently lost
any member a newer writer had added inside its elements. Encode now inspects
the array as read: if any element carries a member its typed schema does not
know, at any depth, it returns ErrRecordExtensionConflict naming the array and
the first such member. Arrays without such members are still replaced whole,
unchanged arrays are still kept verbatim, and arrays inside unknown members are
never inspected.
* docs: record the codec move and the array extension-conflict rule
Records 8db9771fb and c617914a1. T1 and Section 10 now name
domains/ec2/instance/state as the eventual owner of the persisted instance
record and its evolution, with vm.InstanceRecord as the temporary legacy type
it wraps. C3 replaces the changed-array limitation with the refusal: a changed
array with element extensions fails with ErrRecordExtensionConflict and is never
silently dropped. P2 stays a conservative rule until finalisation.
* fix: refuse removals that would drop record extension fields
A capable writer may no longer remove or replace a known object, map entry or
array when its stored value carries members the writer's schema does not know.
The check that guarded changed arrays now runs wherever the merge drops or
overwrites a stored value instead of merging into it: a known member deleted or
set to null, a map entry removed or stored under a key the typed decode
rewrote, a value of another JSON kind, and a changed array. Encode returns
ErrRecordExtensionConflict naming the changed container and the first unknown
member. Removal stays allowed when the stored value has no extensions, and a
change merged member by member still keeps unknown members.
* docs: record the uniform extension-conflict rule
Adds design clause C8 for 0d7b4266d: a capable writer may not remove or
replace a known object, map entry or array whose stored value carries unknown
structured extension fields; removal without extensions stays allowed. C3 and
C5 point at it. The migration record gains the commit row, updated subsection
wording and a pointer-bump follow-up deferring make docs-portal to the Mulga
gitlink PR so the portal evaluates the proposed Spinifex revision.
* refactor: inject vpcd's IMDS instance-state readers from the instance state boundary
* docs: cite the vpcd reader injection commit in the migration record
* refactor: move vpcd to runtime/roles/vpcd
* docs: cite the vpcd move commit in the migration record
* refactor: move the ECS agent wire vocabulary to contracts/ecs/v1
Move handlers/ecs/bus to contracts/ecs/v1 (package ecsv1) with no legacy
shim. Subject strings, JSON fields and types are byte-identical; the old-agent
compatibility test moves unchanged and golden pins cover the remaining
message types. The README route table records that only service-reconcile
has a live producer today; the agent reuses these payload types through the
gateway actions. service-interfaces.yaml lists ecs.bus.* under the daemon.
* refactor: move system-image promotion to domains/ec2/image
Move images_promote.go and its tests from admin to domains/ec2/image:
SystemOwnerAlias, PromoteImageOpts/PromoteImageResult, PromoteSystemImage,
GetAMIMetadata and the private snapshot reader. Storage, ordering, errors and
promotion behaviour are unchanged; the daemon, gateway/spx and operator CLI
callers import ec2image. admin now holds only account IDs and key generators.
* docs: record the ECS contract and image-promotion moves and the remaining-roots matrix
* refactor: move the bootstrap account identifiers to foundation/aws/identifiers
DefaultAccountID and DefaultAccountName join GlobalAccountID as the fixed,
platform-reserved identity of the first human-facing bootstrap account.
Names and values are unchanged and stay fixed. Callers in daemon, gateway,
awsgw, accountteardown and the operator CLI use awsidentifiers; admin now
holds only the IAM credential generators.
* docs: cite the bootstrap account identifier move in the migration record
* refactor: inject the STS cluster JWKS lookup from handlers/eks
handlers/sts declares ClusterJWKSResolver and keeps JWKS decoding and
InvalidIdentityToken mapping; handlers/eks implements it as
OIDCJWKSReader beside the bucket and key layout helpers. awsgw and the
integration harness inject the reader. STS no longer imports any EKS
package, including tests, and the handlers/sts -> handlers/eks layering
exception is removed.
* docs: cite the STS JWKS resolver cut in the migration record
* refactor: move the AWS credential-format generators to foundation/aws/credentials and retire admin
GenerateAWSAccessKey and GenerateAWSSecretKey move unchanged to
foundation/aws/credentials as a stateless format primitive. handlers/iam
and operator/cli import it directly. The admin legacy root is deleted
and joins the retired roots so it cannot return.
* docs: cite the admin retirement in the migration record
* revert: remove the uncalled ADR-0007 codec and design stack from the ADR-0001 checkpoint
The instance transition-record codec, its tests and the slice 1a design
had no production caller. They leave this package-boundary checkpoint
and will be reapplied on a dedicated ADR-0007 branch. Slice 0
characterisation and the vpcd IMDS readers in
domains/ec2/instance/state stay.
* docs: cite the ADR-0007 codec revert in the migration record
* fix: declare the ECS action subjects in service-interfaces.yaml
Declaring ecs.bus.* made ecs a managed prefix for manifest-lint, which then
failed on the 34 ECS action subjects the daemon registers. Declare them as
ecs.*, the same wildcard convention as rds.*.
* chore: run manifest-check and manifest-lint in preflight
CI runs both, but preflight did not, so manifest drift could pass local
checks and still fail Build and Test.
* docs: record resumed preflight enforcement and dev merge ports
* fix: restore dev changes dropped by earlier merges
Reapplies the slices.ContainsFunc rewrite in nodeFitsCustomerInstance and the DeleteDBSubnetGroup doc comment, both lost when their files were refactored.
* docs: record accountteardown as a frozen legacy root pending cleanup capabilities
---------
Co-authored-by: Julian Sommer <115516918+juliansommer@users.noreply.github.com>
37 KiB
EKS managed add-on: per-bundle readiness and removal inventory
Code read at 3a55e2ee1; not verified live.
This is a discovery record for the add-on lifecycle work: for every bundle in the catalogue it lists what is rendered, how identity is wired, what "ready" currently proves, what removal deletes and leaves, and where the bundle collides with other objects.
It proposes no design; gaps are stated per bundle and collected at the end.
It complements docs/package-boundary/eks-addon-lifecycle.md (present contract) and docs/package-boundary/eks-addon-lifecycle-design.md (draft correction, which refines open proposal Q-146: delete holds until owned objects and identity associations are observably removed, and ACTIVE means workloads applied and ready).
Paths starting spinifex/ are Go sources; scripts/ and tests/ are relative to the spinifex repo root; bundle files are under scripts/images/eks-node/addons/<addon>/<version>/ and are abbreviated to <addon>/<version>/<file>.
The sync agent scripts/images/eks-node/mulga-eks-addon-sync.sh is abbreviated to sync.sh.
1. Catalogue
| Name | Version | RequiresIRSA |
Hidden | Evidence |
|---|---|---|---|---|
aws-load-balancer-controller |
2.11.0 | true | no | spinifex/domains/eks/addon/catalog.go:31-33 |
argocd |
3.0.23 | false | no | catalog.go:34-36 |
aws-ebs-csi-driver |
1.40.1 | true | no | catalog.go:37-39 |
nvidia-device-plugin |
0.17.4 | false | yes (auto-staged by GPU node groups) | catalog.go:42-44, spinifex/domains/eks/addon/owner.go:79-89, spinifex/handlers/eks/nodegroup.go:408-416 |
spinifex-noop |
0.1.0 | false | yes (e2e fixture) | catalog.go:48-50 |
RequiresIRSA is read only by DescribeAddonVersions as requiresIamPermissions (spinifex/handlers/eks/addons.go:255); CreateAddon neither requires a role for the two true bundles nor rejects one for the three false bundles (addons.go:61-99).
The bundle manifests are baked into the AMI (scripts/images/eks-node/manifest.conf:58-67), but container images are not: every image below is pulled from a public registry at pod start.
2. AWS reference semantics
Checked against the API reference on 2026-10-09.
| Item | AWS documents | Source |
|---|---|---|
status |
Enum CREATING, ACTIVE, CREATE_FAILED, UPDATING, DELETING, DELETE_FAILED, DEGRADED, UPDATE_FAILED; the API reference gives no per-value definition of ACTIVE or DEGRADED. |
API_Addon |
health |
AddonHealth.issues, a list of AddonIssue. |
API_AddonHealth |
AddonIssue |
code one of AccessDenied, InternalFailure, ClusterUnreachable, InsufficientNumberOfReplicas, ConfigurationConflict, AdmissionRequestDenied, UnsupportedAddonModification, K8sResourceNotFound, AddonSubscriptionNeeded, AddonPermissionFailure; plus message and resourceIds. |
API_AddonIssue |
serviceAccountRoleArn |
"The ARN of the IAM role that's bound to the Kubernetes ServiceAccount object that the add-on uses"; on create, "If you don't specify an existing IAM role, then the add-on uses the permissions assigned to the node IAM role", and an IAM OIDC provider must exist for the cluster. |
API_Addon, API_CreateAddon |
configurationValues |
"validated against the schema returned by DescribeAddonConfiguration". |
API_CreateAddon |
resolveConflicts |
NONE/PRESERVE leave a self-managed install's values and may fail creation; OVERWRITE replaces them; with no prior install all three behave alike. |
API_CreateAddon |
DeleteAddon |
"When you remove an add-on, it's deleted from the cluster"; preserve "preserves the add-on software on your cluster but Amazon EKS stops managing any settings for the add-on. If an IAM account is associated with the add-on, it isn't removed." The example response is DELETING. |
API_DeleteAddon |
The issue codes imply AWS distinguishes replica shortfall (InsufficientNumberOfReplicas), missing objects (K8sResourceNotFound), field conflicts (ConfigurationConflict) and admission denials; how EKS computes them, and whether DEGRADED is driven by them, is not stated in the API reference and was not verified.
Whether AWS offers each of these five names as an EKS add-on was not checked against a live DescribeAddonVersions.
3. Shared mechanics (apply to every bundle)
3.1 Render
| Step | Behaviour | Evidence |
|---|---|---|
| Input | One TSV line per staged add-on: name, version, roleArn, base64(configurationValues). |
spinifex/agents/eks/gatewayfetch/fetch.go emitAddonsTSV, sync.sh:357 |
| Source | Every *.yaml in /usr/share/spinifex-eks/addons/<name>/<version>/, in glob order, concatenated with ---. A missing directory reports failed. |
sync.sh:41, sync.sh:82-89, sync.sh:219-242 |
| Output | One file per add-on name, /var/lib/rancher/k3s/server/manifests/spinifex-addon-<name>.yaml; the name carries no version. Replaced only when content changes. |
sync.sh:42-43, sync.sh:83, sync.sh:248-253 |
| Block markers | {{IRSA_ENV}}, {{IRSA_VOLUME}}, {{IRSA_VOLUME_MOUNT}}, {{ELB_INGRESS_PARAMS_SPEC}} replaced by awk when alone on a line. |
sync.sh:224-230 |
| Scalar placeholders | {{SERVICE_ACCOUNT_ROLE_ARN}}, {{CLUSTER_NAME}}, {{AWS_REGION}}, {{AWS_VPC_ID}}, {{GATEWAY_ENDPOINT}}, {{GATEWAY_CA_PEM_B64}}, {{WEBHOOK_CA_B64}}, {{WEBHOOK_TLS_CRT_B64}}, {{WEBHOOK_TLS_KEY_B64}} via `sed s |
.. |
| Webhook cert | Opt-in by webhook.conf; minted once per add-on under /var/lib/spinifex-eks/webhook-certs/<name>, 10-year validity, reused thereafter. |
sync.sh:98-120, spinifex/agents/eks/webhookcert/cert.go:109-110 |
configurationValues |
Read from the TSV and discarded; no bundle has a hook. | sync.sh:359 |
| Executor | Primary server only; server-join nodes do not run the agent. | scripts/images/eks-node/eks-node-role.sh:138-149 |
3.2 Identity (IRSA) wiring
| Element | Present behaviour | Evidence |
|---|---|---|
| Role carrier | The role ARN lives in the add-on record and the staged manifest (serviceAccountRoleArn), and after render in the rendered file only. No pod identity association, no EKS-side binding object. |
spinifex/domains/eks/addon/record.go:24-45, sync.sh:144-160 |
| Credential env | With a role: AWS_ROLE_ARN, AWS_WEB_IDENTITY_TOKEN_FILE, AWS_STS_REGIONAL_ENDPOINTS, region, AWS_ENDPOINT_URL_STS (gateway), AWS_CA_BUNDLE and SSL_CERT_FILE. Without one: region and CA only, so the SDK falls through to node instance-profile credentials over IMDS. |
sync.sh:144-195 |
| Token | A projected ServiceAccount token, audience sts.amazonaws.com, 86400 s, mounted at /var/run/secrets/eks.amazonaws.com/serviceaccount, injected statically by the render. There is no pod-identity mutating webhook in the image, so the eks.amazonaws.com/role-arn ServiceAccount annotation is descriptive only; the env and volume are what take effect. |
sync.sh:161-178; no pod-identity-webhook in the tree |
| Issuer | The apiserver's /openid/v1/jwks is published at first boot; STS AssumeRoleWithWebIdentity resolves iss to a registered IAM OIDC provider in the role's account, fetches the cluster JWKS, and evaluates the role trust policy ({iss}:sub, {iss}:aud). |
scripts/images/eks-node/k3s-first-boot.sh:141-162, spinifex/handlers/sts/assume_role_with_web_identity.go:33-213, spinifex/handlers/sts/web_identity_trust_policy.go:137-170 |
| Objects outside the bundle | The IAM role, its trust policy (naming system:serviceaccount:<ns>:<sa>) and the IAM OIDC provider are user-owned IAM objects; nothing in the add-on path creates, modifies or deletes them. |
tests/e2e/eks/eks_test.go:658-700 creates them in the test |
| Authorisation | iam:PassRole on the role at CreateAddon and UpdateAddon. |
spinifex/gateway/eks/passrole.go:31-37 |
eks-token-webhook |
Not part of IRSA: it is the apiserver TokenReview authenticator for aws eks get-token bearer tokens. |
scripts/images/eks-node/eks-token-webhook.initd:1-8 |
Because identity association lives only in IAM (user-owned) and in the rendered pod spec, "identity associations observably removed" has no Spinifex-side object to observe for any bundle today: the role is not detached from anything when the add-on is deleted, matching AWS only in that AWS also does not delete the IAM role.
3.3 Readiness
| Path | Condition | Evidence |
|---|---|---|
| Primary | The K3s Addon CR in kube-system whose .spec.source is the rendered file carries a non-empty addon.k3s.cattle.io/gvks annotation. Reported ready on every tick this holds. No pod, replica or CRD condition is consulted. |
sync.sh:266-273, sync.sh:361-365 |
| Fallback | Only after ADDON_READY_GRACE (90 s) with the annotation still empty: kubectl get -f <rendered> --ignore-not-found, then require at least one Deployment, StatefulSet or DaemonSet and that every one returned is rolled out (Deployment availableReplicas >= spec.replicas and generation observed; StatefulSet readyReplicas >= spec.replicas; DaemonSet desiredNumberScheduled > 0 and numberReady >= desiredNumberScheduled). |
sync.sh:56, sync.sh:301-320, sync.sh:367-372 |
| Otherwise | applied, which changes no status. |
sync.sh:374-376, spinifex/domains/eks/addon/owner.go:186-205 |
failed |
Emitted only for a missing bundle directory or webhook cert failure; never for apply errors, crash-looping pods or lost replicas. | sync.sh:87, sync.sh:112 |
| Status mapping | ready lifts any non-ACTIVE status (including CREATE_FAILED, DEGRADED, UPDATING) to ACTIVE and clears health; failed maps ACTIVE to DEGRADED. Reports carry no generation. |
owner.go:140-168, owner.go:186-205 |
Consequences common to all bundles:
- On the primary path
readymeans "K3s recorded the GVKs it applied", not "workloads running"; a bundle whose pods never start (image pull failure, unschedulable, crash loop) isACTIVEand stays so. ACTIVEnever degrades on workload loss: the annotation persists, soreadyis re-sent every tick and nofailedis ever produced for runtime health.--ignore-not-founddrops absent objects from the fallback set, so a workload that failed to apply is simply not checked; one rolled-out workload is enough.- After
UpdateAddonthe same tick that rewrites the file reads the annotation from the previous apply; whether K3s clears it before that read is not established, soUPDATINGmay settleACTIVEon the old apply (the agent comment atsync.sh:244-247says a re-apply clears it, which suggests a window exists). - The agent never deletes the K3s
AddonCR; if K3s keeps that CR after the file is removed, a later re-create would match it by.spec.sourceand could reportreadyfrom a stale annotation before the new apply (K3s behaviour not verified).
3.4 Removal
| Step | Behaviour | Evidence |
|---|---|---|
| Trigger | A rendered spinifex-addon-<name>.yaml whose name is absent from a successful fetch. A failed fetch skips GC. |
sync.sh:344-348, sync.sh:386-391 |
| Selection | The object list is the rendered file itself (kubectl delete -f), not labels or a GVK inventory. Objects created at runtime by the add-on, or by users through it, are never selected. |
sync.sh:397-401 |
| Order | File order, which is glob order of the bundle files then document order. | sync.sh:219 |
| Waiting | --wait=false; errors go to syslog; the copy is deleted; nothing is reported. |
sync.sh:400-402 |
| Leftovers on the node | /var/lib/spinifex-eks/webhook-certs/<name> and the K3s Addon CR. The /tmp sentinels are cleared. |
sync.sh:47, sync.sh:393 |
| Control plane | Record and manifest keys are erased before any guest action. | owner.go:122-137 |
| Namespace completion | Namespace deletion needs every aggregated API available; the e2e asserts v1beta1.metrics.k8s.io is Available first because otherwise the namespace stays Terminating. |
tests/e2e/eks/eks_test.go:197-231 |
preserve is ignored (record eks-addon-lifecycle.md row Desired state); for every bundle a preserve would need to keep the whole rendered object set and stop only the render and GC, so the per-bundle preserve rows below list what in addition would break or dangle.
4. spinifex-noop 0.1.0
Objects
| Kind | Name | Namespace | Source |
|---|---|---|---|
| Namespace | spinifex-noop |
spinifex-noop/0.1.0/noop.yaml:5-10 |
|
| ConfigMap | spinifex-noop |
spinifex-noop |
noop.yaml:12-20 |
Images: none.
Both objects carry app.kubernetes.io/managed-by: spinifex-addon (noop.yaml:9-10, noop.yaml:17-18); nothing reads the label.
Identity
No IRSA markers, no ServiceAccount; a supplied serviceAccountRoleArn is stored and inert.
Readiness
| Question | Answer |
|---|---|
| Primary path | Ready once K3s records the two GVKs. This is the path the e2e exercises (tests/e2e/eks/eks_test.go:158-195). |
| Fallback | Never succeeds: no workload kinds, so length > 0 is false (sync.sh:308). |
| Meaning of ready | Both objects applied; there is nothing to serve. |
| False ready | None material. |
Removal
| Question | Answer |
|---|---|
| Deleted | Namespace (cascading the ConfigMap) and ConfigMap. |
| Left behind | The K3s Addon CR. |
| Preserve | Keep both; nothing dangles. |
| Completion signal | kubectl get ns spinifex-noop NotFound; this is exactly what the e2e asserts (eks_test.go:221-231). Blocked indefinitely by an unavailable aggregated API. |
Conflicts and configuration
Namespace name could collide with a user namespace of the same name, which GC would then delete. No configuration hook.
Gaps
- The only bundle with removal proven end-to-end; its completion signal (namespace NotFound) does not generalise to bundles in
kube-system.
5. argocd 3.0.23
Objects
Single file argocd/3.0.23/argocd.yaml (26,819 lines), upstream install.yaml passed through kustomize with namespace: argocd (argocd.yaml:1-11).
| Kind | Count | Names | Namespace | Evidence |
|---|---|---|---|---|
| Namespace | 1 | argocd (first document) |
argocd.yaml:12-17 |
|
| CustomResourceDefinition | 3 | applications.argoproj.io, applicationsets.argoproj.io, appprojects.argoproj.io |
argocd.yaml:25, :5904, :23563 |
|
| ServiceAccount | 7 | argocd-application-controller, -applicationset-controller, -dex-server, -notifications-controller, -redis, -repo-server, -server |
argocd |
parsed |
| Role / RoleBinding | 6 / 6 | per component | argocd |
parsed |
| ClusterRole / ClusterRoleBinding | 3 / 3 | argocd-application-controller, argocd-applicationset-controller, argocd-server |
argocd.yaml:24243-24554 |
|
| ConfigMap | 7 | argocd-cm, -cmd-params-cm, -gpg-keys-cm, -notifications-cm, -rbac-cm, -ssh-known-hosts-cm, -tls-certs-cm |
argocd |
parsed |
| Secret | 2 | argocd-notifications-secret, argocd-secret |
argocd |
argocd.yaml:24740, :24751 |
| Service | 8 | applicationset-controller, dex-server, metrics, notifications-controller-metrics, redis, repo-server, server, server-metrics | argocd |
parsed |
| Deployment | 6 | argocd-applicationset-controller, -dex-server, -notifications-controller, -redis, -repo-server, -server (default 1 replica) |
argocd |
argocd.yaml:24925-25887 |
| StatefulSet | 1 | argocd-application-controller, 1 replica |
argocd |
argocd.yaml:26301-26310 |
| NetworkPolicy | 7 | one per component | argocd |
parsed |
Images: quay.io/argoproj/argocd:v3.0.23 (8 containers), ghcr.io/dexidp/dex:v2.41.1 (argocd.yaml:25243), redis:7.2.11-alpine (argocd.yaml:25478).
Only the Namespace carries app.kubernetes.io/managed-by: spinifex-addon.
Identity
No IRSA markers (argocd.yaml:11); a supplied role is stored and inert.
All seven ServiceAccounts are created by the bundle.
Readiness
| Question | Answer |
|---|---|
| Primary path | Per the agent comment, K3s never records the gvks annotation for this bundle, so the primary path does not fire (sync.sh:49-55); why is not established. |
| Fallback | After 90 s: all 6 Deployments available at 1 replica and the StatefulSet at 1 ready replica, among those kubectl get -f finds. |
| Meaning of ready | Every returned workload rolled out once. CRDs are not checked for Established; an absent CRD or workload is dropped by --ignore-not-found rather than failing the check. |
| False ready | A partial apply that left any document unapplied still reads ready if the remaining workloads roll out; if the missing gvks is caused by an apply error on one object, this is the case in practice (hypothesis, not verified). Dex and notifications are counted though unused by default. |
| Runtime | Images pulled from three public registries; on an air-gapped site the bundle never rolls out and stays CREATING. |
Removal
| Question | Answer |
|---|---|
| Deleted | Everything in the file, Namespace first. CRD deletion removes every Application, ApplicationSet and AppProject in the cluster, including the runtime default AppProject. |
| Left behind | Workloads Argo CD deployed into other namespaces (user applications) unless their Application carries the cascade finalizer and the controller survives long enough to process it; runtime Secrets in argocd go with the namespace. |
| Stuck risk | Application objects carrying resources-finalizer.argocd.argoproj.io (user-set, upstream behaviour) need the application controller to clear them; it is deleted in the same pass, so the CRs, the applications CRD and the argocd namespace can stay Terminating indefinitely (not verified live). |
| Preserve | Keep all objects; the cluster-scoped ClusterRoles and CRDs then remain unowned. |
| Completion signal | argocd namespace NotFound and the three CRDs NotFound and the three ClusterRoles and ClusterRoleBindings NotFound; namespace and CRD finalizers must be watched explicitly, since NotFound on the namespace alone does not cover cluster-scoped objects. |
Conflicts and configuration
A user-installed Argo CD (same CRDs, same ClusterRole names, namespace argocd) would be overwritten on create and wholly deleted on DeleteAddon; this is the resolveConflicts case.
No configuration hook, although argocd-cm/argocd-rbac-cm are the natural targets.
Gaps
- Readiness depends entirely on the fallback, which neither checks CRDs nor detects missing objects.
- Removal deletes user-owned
Applicationdata cluster-wide and can wedge on finalizers; nothing reports it. - No e2e coverage at all.
6. aws-ebs-csi-driver 1.40.1
Objects
| Kind | Name | Namespace | Source |
|---|---|---|---|
| ServiceAccount | ebs-csi-controller-sa (role annotation) |
kube-system |
aws-ebs-csi-driver/1.40.1/00-rbac.yaml:5-14 |
| ServiceAccount | ebs-csi-node-sa |
kube-system |
00-rbac.yaml:16-23 |
| ClusterRole | ebs-external-attacher-role, ebs-csi-node-role, ebs-external-provisioner-role, ebs-external-resizer-role, ebs-external-snapshotter-role |
00-rbac.yaml:25, :65, :94, :184, :241 |
|
| ClusterRoleBinding | ebs-csi-attacher-binding, ebs-csi-node-getter-binding, ebs-csi-provisioner-binding, ebs-csi-resizer-binding, ebs-csi-snapshotter-binding |
00-rbac.yaml:309-381 |
|
| Role / RoleBinding | ebs-csi-leases-role / ebs-csi-leases-rolebinding |
kube-system |
00-rbac.yaml:384-417 |
| CSIDriver | ebs.csi.aws.com |
00-rbac.yaml:421-430 |
|
| PodDisruptionBudget | ebs-csi-controller (maxUnavailable 1) |
kube-system |
00-rbac.yaml:432-443 |
| Secret | spinifex-gateway-ca (shared name, see Conflicts) |
kube-system |
10-controller.yaml:8-17 |
| Deployment | ebs-csi-controller, 2 replicas, preferred anti-affinity, tolerates CriticalAddonsOnly and nvidia.com/gpu |
kube-system |
10-controller.yaml:19-82 |
| DaemonSet | ebs-csi-node, tolerates nvidia.com/gpu only |
kube-system |
20-node.yaml:5-58 |
| StorageClass | ebs-gp3, default class, WaitForFirstConsumer |
30-storageclass.yaml:5-18 |
Images: public.ecr.aws/ebs-csi-driver/aws-ebs-csi-driver:v1.40.1 (10-controller.yaml:89, 20-node.yaml:67), public.ecr.aws/eks-distro/kubernetes-csi/external-provisioner:v5.2.0-eks-1-32-7 (:147), external-attacher:v4.8.1-eks-1-32-7 (:180), external-snapshotter/csi-snapshotter:v8.2.1-eks-1-32-7 (:209), external-resizer:v1.13.2-eks-1-32-7 (:238), livenessprobe:v2.14.0-eks-1-32-7 (:270, 20-node.yaml:155), node-driver-registrar:v2.13.0-eks-1-32-7 (20-node.yaml:118).
The bundle header says it is vendored from upstream v1.41.0 while the catalogue version is 1.40.1 (00-rbac.yaml:1-3); the driver image is v1.40.1.
Identity
| Question | Answer |
|---|---|
Takes serviceAccountRoleArn |
Yes (RequiresIRSA), not required at create. |
| Annotated SA | ebs-csi-controller-sa (00-rbac.yaml:12-13, quoted, so an empty role renders ''). |
| Injected pod | Controller Deployment only: {{IRSA_ENV}} (10-controller.yaml:110), {{IRSA_VOLUME_MOUNT}} (:114), {{IRSA_VOLUME}} (:289). The node DaemonSet gets no credentials and makes no EC2 calls (20-node.yaml:1-3). |
| SA owner | The bundle creates both ServiceAccounts. |
| Without a role | Controller uses node instance-profile credentials over IMDS. |
| Evidence | tests/e2e/eks/eks_test.go:658-800 installs it with a role, creates the OIDC provider and role, and drives a PVC through CreateVolume/AttachVolume. |
Readiness
| Question | Answer |
|---|---|
| Primary path | ready as soon as K3s records GVKs; neither replica need be running. The e2e waits for ACTIVE and then separately proves the data path (eks_test.go:767-800). |
| Fallback | Controller Deployment 2 of 2 available and node DaemonSet desired > 0 and all ready. |
| Fallback false negative | A cluster with no worker node that tolerates scheduling (only the control plane, which carries CriticalAddonsOnly the DaemonSet does not tolerate) has desired = 0, so the fallback never passes. |
| False ready | Controller pending or crash-looping (including STS web-identity failures from a bad trust policy), or sidecars failing, still ACTIVE via the primary path. The bundle ships no VolumeSnapshot CRDs while running csi-snapshotter; the sidecar's behaviour without them was not verified and nothing in readiness would show it. |
| AWS comparison | InsufficientNumberOfReplicas and AccessDenied are the codes that would correspond to these states; neither is ever produced. |
Removal
| Question | Answer |
|---|---|
| Deleted | All objects above, including the default StorageClass and the CSIDriver, in file order (RBAC and CSIDriver first, then Secret and controller, then node DaemonSet, then StorageClass). |
| Left behind (in cluster) | PersistentVolumes and PVCs it provisioned; VolumeAttachment objects; runtime leader-election Leases in kube-system; CSINode driver entries until node plugins unregister. |
| Left behind (outside cluster) | Spinifex EBS volumes backing those PVs, still allocated and possibly attached. |
| Stuck risk | PVs with reclaimPolicy: Delete and VolumeAttachments carry CSI sidecar finalizers that only the deleted controller clears, so later PVC deletion or node drain hangs and the backing volume is never deleted (upstream sidecar behaviour, not verified on this build). |
| Preserve | Keep the whole set; existing mounts and new provisioning keep working with the last-rendered role. |
| Completion signal | All 20 rendered objects NotFound (all in kube-system or cluster-scoped, so there is no namespace to watch); a meaningful "removed" additionally needs zero VolumeAttachments and PVs with spec.csi.driver == ebs.csi.aws.com, or an explicit statement that those are user data that outlive the add-on. |
Conflicts and configuration
| Object | Collides with |
|---|---|
kube-system/spinifex-gateway-ca |
The identical name in aws-load-balancer-controller (10-aws-load-balancer-controller.yaml:33-41). Deleting either add-on deletes the Secret the other mounts; K3s re-applies the survivor's file only when it changes, so the survivor's next pod start fails until then (re-apply behaviour not verified). A removal check by NotFound on this Secret also never completes while the other add-on re-creates it. |
StorageClass/ebs-gp3 with is-default-class |
Any user default StorageClass, giving two defaults; K3s local-storage is disabled (scripts/images/eks-node/setup.sh:98-101). |
CSIDriver/ebs.csi.aws.com, the five ClusterRoles, ebs-csi-* names |
A self-managed (Helm) EBS CSI install, the resolveConflicts case; DeleteAddon would remove the user's driver too. |
No configuration hook; upstream exposes replica count, tolerations and StorageClass parameters through Helm values.
Gaps
ACTIVEdoes not imply a running controller or working credentials.- Removal orphans PVs, VolumeAttachments and Spinifex volumes, and can wedge them behind finalizers.
- Shares
spinifex-gateway-cawith the load balancer controller, so removal of either is not isolated. - Bundle provenance comment (v1.41.0) disagrees with the catalogue version (1.40.1).
7. aws-load-balancer-controller 2.11.0
Objects
| Kind | Name | Namespace | Source |
|---|---|---|---|
| CustomResourceDefinition | ingressclassparams.elbv2.k8s.aws |
aws-load-balancer-controller/2.11.0/00-crds.yaml:1-8 |
|
| CustomResourceDefinition | targetgroupbindings.elbv2.k8s.aws |
00-crds.yaml:256-263 |
|
| ServiceAccount | aws-load-balancer-controller (role annotation, unquoted) |
kube-system |
10-aws-load-balancer-controller.yaml:2-13 |
| Secret | aws-load-balancer-webhook-tls (node-minted cert) |
kube-system |
10-…yaml:17-28 |
| Secret | spinifex-gateway-ca (shared name) |
kube-system |
10-…yaml:32-41 |
| Role / RoleBinding | aws-load-balancer-controller-leader-election-role / -rolebinding |
kube-system |
10-…yaml:44-48, :242-254 |
| ClusterRole / ClusterRoleBinding | aws-load-balancer-controller-role / -rolebinding |
10-…yaml:85-89, :258-269 |
|
| Service | aws-load-balancer-webhook-service |
kube-system |
10-…yaml:273-277 |
| Deployment | aws-load-balancer-controller, 1 replica, tolerates CriticalAddonsOnly and nvidia.com/gpu |
kube-system |
10-…yaml:288-372 |
| List → IngressClassParams | alb (subnets injected from EKS_ELB_SUBNET_IDS) |
10-…yaml:375-386, sync.sh:197-215 |
|
| List → IngressClass | alb |
10-…yaml:388-400 |
|
| MutatingWebhookConfiguration | aws-load-balancer-webhook: mservice (Services, all namespaces), mpod (Pods in namespaces labelled elbv2.k8s.aws/pod-readiness-gate-inject), mtargetgroupbinding; all failurePolicy: Fail |
10-…yaml:402-488 |
|
| ValidatingWebhookConfiguration | aws-load-balancer-webhook: vingressclassparams, vtargetgroupbinding, vingress; all failurePolicy: Fail |
10-…yaml:489-564 |
Image: public.ecr.aws/eks/aws-load-balancer-controller:v2.11.0 (10-…yaml:320).
Webhook SANs come from webhook.conf (aws-load-balancer-controller/2.11.0/webhook.conf).
Identity
| Question | Answer |
|---|---|
Takes serviceAccountRoleArn |
Yes (RequiresIRSA), not required at create. |
| Annotated SA | aws-load-balancer-controller (10-…yaml:11-12); the placeholder is unquoted, so the raw ARN becomes a YAML scalar and an empty role renders a null annotation value. |
| Injected pod | Controller Deployment: {{IRSA_ENV}} (:319), {{IRSA_VOLUME_MOUNT}} (:349), {{IRSA_VOLUME}} (:372); STS, EC2, ELBv2 and ACM endpoints pinned to the gateway by args (:309-314). |
| SA owner | The bundle. |
| Without a role | Node instance-profile credentials over IMDS. |
| Evidence | No e2e installs this add-on; IRSA is proven only for EBS CSI and a hand-written pod (tests/e2e/eks/eks_test.go:234-247). |
Readiness
| Question | Answer |
|---|---|
| Primary path | ready when GVKs are recorded; the controller need not be running. |
| Fallback | The one Deployment at 1 available replica. |
| False ready | Controller pending, crash-looping, or failing STS/ELBv2 calls is still ACTIVE. Worse than a passive false ready: with the controller absent, the six failurePolicy: Fail webhooks reject every Service create or update cluster-wide (mservice matches all namespaces except LBC's own objects) and every Ingress, so an ACTIVE add-on can break unrelated workloads. CRD Established is not checked. |
| AWS comparison | AdmissionRequestDenied and InsufficientNumberOfReplicas are the matching issue codes; neither is produced. |
Removal
| Question | Answer |
|---|---|
| Deleted | CRDs first (00 file sorts first), then ServiceAccount, Secrets, RBAC, Service, Deployment, IngressClassParams, IngressClass, and the webhook configurations last. |
| Left behind (in cluster) | User Ingresses and LoadBalancer Services it reconciled, with the controller's finalizers still set; the runtime leader Lease. |
| Left behind (outside cluster) | Spinifex ELBv2 load balancers, target groups, listeners and any security groups the controller created for those Ingresses and Services. |
| Stuck risk | Deleting the targetgroupbindings CRD waits on TargetGroupBindings whose finalizer only the controller clears; user Ingresses and Services keep finalizers no one removes, so they cannot be deleted (upstream controller behaviour, not verified on this build). Between the Deployment deletion and the webhook deletion, Service and Ingress writes fail; if the webhook delete errors, that state persists. |
| Preserve | Keep the whole set; the webhook cert and gateway CA must stay valid (cert is 10-year). |
| Completion signal | All rendered objects NotFound plus both CRDs gone (no Terminating); a meaningful "removed" also needs no remaining object carrying the controller's finalizers and no remaining Spinifex ELBv2 resources tagged for this cluster, which only the host side can observe. |
Conflicts and configuration
| Object | Collides with |
|---|---|
kube-system/spinifex-gateway-ca |
aws-ebs-csi-driver (Section 6). |
IngressClass/alb, IngressClassParams/alb |
Any user IngressClass named alb, including a self-managed LBC. |
| CRDs, ClusterRole, webhook configuration names | A self-managed LBC (Helm), the resolveConflicts case. |
No configuration hook; EKS_ELB_SUBNET_IDS is the only per-cluster input and it comes from the node environment, not from configurationValues.
The design draft names this bundle as the first configuration target.
Gaps
ACTIVEcan coexist with fail-closed webhooks that have no backend, which breaks Service and Ingress writes cluster-wide.- Removal orphans user Ingresses/Services behind finalizers and Spinifex ELBv2 resources outside the cluster; nothing in the guest can observe the latter.
- Shares
spinifex-gateway-cawith EBS CSI. - Unquoted role placeholder takes the raw ARN as YAML.
- No e2e coverage.
8. nvidia-device-plugin 0.17.4
Objects
| Kind | Name | Namespace | Source |
|---|---|---|---|
| DaemonSet | nvidia-device-plugin-daemonset; nodeSelector nvidia.com/gpu.present=true; tolerates nvidia.com/gpu; runtimeClassName: nvidia; hostPath / read-only, /var/lib/kubelet/device-plugins, /var/run/cdi |
kube-system |
nvidia-device-plugin/0.17.4/10-daemonset.yaml:14-75 |
Image: nvcr.io/nvidia/k8s-device-plugin:v0.17.4 (10-daemonset.yaml:41).
Depends on a RuntimeClass named nvidia and on the node label written by mulga-eks-provider-id (10-daemonset.yaml:1-12); neither is in the bundle.
Identity
No IRSA markers and no ServiceAccount object: pods run as the kube-system/default ServiceAccount that Kubernetes creates.
EnsureGPUDevicePlugin stages it with no role (owner.go:79-89); a user-created one may carry an inert role.
Readiness
| Question | Answer |
|---|---|
| Primary path | ready when K3s records the DaemonSet GVK, regardless of GPU nodes. |
| Fallback | Requires desiredNumberScheduled > 0: never passes on a cluster with no GPU node. |
| False ready | ACTIVE with zero GPU nodes (nothing serving); ACTIVE after every GPU node group is deleted; FAIL_ON_INIT_ERROR=false (10-daemonset.yaml:46-47) and no readiness probe mean a pod whose NVML init failed is Ready while advertising no nvidia.com/gpu. The e2e proves the real signal separately: DaemonSet 1=1 and node allocatable nvidia.com/gpu=1 (tests/e2e/gpu/eks_gpu_test.go:260-275). |
Removal
| Question | Answer |
|---|---|
| Deleted | The DaemonSet. |
| Left behind | CDI spec files the plugin wrote to host /var/run/cdi; node nvidia.com/gpu capacity until kubelet reconciles the unregistered plugin (kubelet behaviour not verified). |
| Re-staging | Deleting it while GPU node groups exist leaves GPUs unschedulable until the next GPU node group create re-stages it; deleting the last GPU node group never unstages it (eks-addon-lifecycle.md row Cross-resource dependency). |
| Preserve | Keep the DaemonSet; nothing dangles. |
| Completion signal | DaemonSet NotFound; pods gone from GPU nodes. |
Conflicts and configuration
A user-installed NVIDIA device plugin or GPU Operator would run a second plugin on the same nodes and contend for the kubelet device-plugin socket; the DaemonSet name matches the upstream static manifest, so a self-managed upstream install is overwritten. No configuration hook (device-list strategy, time-slicing and MIG are upstream options).
Gaps
- Ready is indifferent to whether any GPU is exposed; the workload fallback is unreachable on non-GPU clusters.
- Ownership is split between the auto-stager and the user, with no record of which.
9. Cross-bundle findings
| # | Finding | Bundles | Evidence |
|---|---|---|---|
| X1 | Readiness is "applied" on the primary path; workload state is never consulted while gvks is present, and runtime failure never yields failed. |
all | sync.sh:361-365, sync.sh:87, sync.sh:112 |
| X2 | The fallback silently drops absent objects (--ignore-not-found) and never checks CRD Established. |
argocd, LBC, EBS | sync.sh:304-319 |
| X3 | DaemonSet desired > 0 makes the fallback unreachable for node-dependent bundles on clusters without matching nodes, while the primary path reports ready for the same state. |
EBS, nvidia | sync.sh:317 |
| X4 | Removal selects only objects in the rendered file; runtime-created and user-created dependants (PVs, VolumeAttachments, Applications, Ingresses with finalizers, Leases) are not inventoried, and out-of-cluster resources (EBS volumes, ELBv2) are invisible to the guest. | EBS, LBC, argocd | sync.sh:397-401 |
| X5 | kube-system/spinifex-gateway-ca is rendered by two bundles under one name; either removal deletes the other's dependency, and a NotFound completion check on it is ill-defined while both exist. |
LBC, EBS | 10-aws-load-balancer-controller.yaml:32-41, aws-ebs-csi-driver/1.40.1/10-controller.yaml:8-17 |
| X6 | No bundle has a stable ownership label set: only noop and the argocd Namespace carry managed-by: spinifex-addon; LBC, EBS and nvidia carry only upstream app.kubernetes.io/name labels, which a self-managed install of the same software carries too. A label-based inventory or conflict check has nothing reliable to select on. |
all | per-bundle sources |
| X7 | Identity association is only the rendered pod env plus user-owned IAM objects; there is nothing Spinifex-owned to remove or observe, and the SA annotation is not acted on by any webhook. | LBC, EBS | Section 3.2 |
| X8 | RequiresIRSA is advisory: no create-time check either way, so a role on argocd, nvidia or noop is stored and inert. |
all | addons.go:61-99, addons.go:255 |
| X9 | The role ARN is substituted raw into sed and YAML; only iam:PassRole (which requires the role to exist) constrains it. |
LBC, EBS | sync.sh:231, passrole.go:31-37 |
| X10 | configurationValues has no schema, no DescribeAddonConfiguration, and no render hook for any bundle. |
all | sync.sh:359 |
| X11 | Removal runs only on the primary server and only from the local rendered file; a replaced primary has no file and removes nothing. | all | eks-node-role.sh:138-142, sync.sh:386 |
| X12 | E2E covers create, ready and delete only for noop, create and data path for EBS (delete only in cleanup, not asserted), and DaemonSet rollout for nvidia; argocd and LBC have none. | all | tests/e2e/eks/eks_test.go:158-247, tests/e2e/gpu/eks_gpu_test.go:260-275 |
10. Per-bundle observable removal signal (summary)
| Bundle | Objects that must be NotFound | Finalizer or dependant to watch | Out-of-cluster residue |
|---|---|---|---|
spinifex-noop |
Namespace spinifex-noop |
Namespace kubernetes finalizer (aggregated API availability) |
none |
argocd |
Namespace argocd, 3 CRDs, 3 ClusterRoles, 3 ClusterRoleBindings |
Application resources finalizer; CRD and namespace Terminating |
none from the bundle; user workloads it deployed |
aws-ebs-csi-driver |
20 objects, all kube-system or cluster-scoped |
PV and VolumeAttachment CSI finalizers | Spinifex EBS volumes |
aws-load-balancer-controller |
2 CRDs plus 13 objects, webhooks included | Ingress, Service and TargetGroupBinding controller finalizers; CRD Terminating |
Spinifex ELBv2 load balancers, target groups, security groups |
nvidia-device-plugin |
1 DaemonSet | none | host CDI spec files |