Etlworks managed releases 10.0.14 and newer include installation profiles for Amazon EKS, Azure AKS and Google GKE Standard. This article covers the cloud-specific procedure: preparing the provider cluster, freezing a cloud plan, configuring and installing with that plan, network access, cloud storage behavior and cloud troubleshooting.
Everything the cloud installation shares with the local profile — downloads, Cluster licensing, archive verification, the base configuration, installation commands, first access, scaling, upgrades, pod sizing, logs, backups and recovery — is in Install Etlworks on Kubernetes: downloads, cluster preparation, installation and recovery. Read that guide first; this article extends it.
In this article
- Cloud platforms and scope
- Check your release before starting
- Cloud platform profiles
- Requirements common to every cloud profile
- Freeze the target cluster and native add-ons into a cloud plan
- Amazon EKS
- Azure AKS
- Google GKE Standard
- Configure and install using the cloud plan
- Network access to the installed application
- Cloud storage identity, holds and retries
- Cloud operations: scaling, upgrades, workers and teardown
- Backups and recovery on cloud profiles
- Cloud troubleshooting
- Related articles
Cloud platforms and scope
The managed release archive ships four platform profiles for Linux AMD64 and ARM64 workers. Three are cloud profiles covered by this article — aws-eks-v1 (Amazon EKS), azure-aks-v1 (Azure AKS) and gcp-gke-standard-v1 (Google GKE Standard) — and the local profile remains available for self-managed clusters.
The cloud profiles use ordinary Linux node pools only. EKS Auto Mode and Fargate, AKS node auto-provisioning, GKE Autopilot, Windows nodes and Spot/preemptible nodes are excluded. The installer does not activate a node autoscaler, and node consolidation and maintenance must respect the drain requirements in the main guide's node-scaling section.
You bring the Kubernetes cluster, worker pools, provider networking and identities, the native CNI/CSI/load-balancer integrations, enabled APIs, quota and the required storage resources. The installer installs or reuses its pinned cert-manager and KEDA assets and creates the namespaced Etlworks resources and retained storage claims. It does not create VPCs or clusters, change IAM or provider registration, replace the native CNI, or enable node autoscaling. Cloud credentials stay on the installation workstation — never in application properties or runtime Secrets.
Check your release before starting
The cloud profile modules ship inside the managed installer ZIP starting with Etlworks 10.0.14. If your downloaded release predates 10.0.14, these modules are absent from its archive. Obtain the matching release and architecture; do not edit an older release's descriptor, copy modules between releases or add an invented --cloud installation flag. The documentation and inventory bundled with your release are authoritative for what that release contains.
Cloud platform profiles
| Platform profile | Required native platform | Shared application/backup storage | Private identities and provisioned databases |
|---|---|---|---|
| aws-eks-v1 | EKS 1.34, ordinary EC2 Linux managed node groups, VPC CNI with network policy enabled, EBS CSI, EFS CSI, AWS Load Balancer Controller | Encrypted EFS with access points, TLS and IAM | Encrypted gp3 EBS volumes, ext4 |
| azure-aks-v1 | AKS 1.34 Linux VMSS node pools, enforced network policy, managed Files/Disk CSI, Standard Load Balancer | Premium Azure Files NFS with encryption in transit | Premium Azure Disk, ext4 |
| gcp-gke-standard-v1 | GKE Standard 1.34, ordinary Linux node pools, enforced network policy, Filestore CSI, PD CSI, private service access | Private Filestore | Balanced persistent disks, ext4 |
Select the profile with the platformProfile setting in the installation configuration. The profile selection is independent of the CPU/RAM resource profile named by your Cluster license: the license controls pod sizing and counts, the platform profile controls where and how the installation runs. Website and license-portal downloads do not require a provider selection. PostgreSQL and Redis remain independent provisioned/external choices under every cloud profile, using the same external-service requirements as the main guide; selecting external mode does not by itself make a specific managed database product compatible with that contract.
Requirements common to every cloud profile
Bring an existing supported cluster and its explicit kubeconfig/context. The installer:
- Reuses the provider's native CNI and CSI. It never installs Calico over a cloud provider's network, creates a cloud cluster or VPC, enables cloud APIs, changes IAM or quotas, or enables a node autoscaler.
- Installs or reuses its pinned cert-manager and KEDA assets. Do not run a second KEDA stack or another HPA on the Etlworks workload.
- Creates namespaced application resources plus retained CSI StorageClasses and PersistentVolumeClaims. The namespace must be new and exclusive to this installation.
On the installation workstation you need Java 25, Python 3.12 or newer, Helm 3, kubectl and your provider's CLI, authenticated to the intended account, subscription or project with a scoped platform identity. Cloud credentials stay on the installer host: do not put cloud credentials in the Etlworks runtime Secrets or application properties.
Use same-architecture ordinary Linux pools and leave resource headroom beyond the licensed application CPU/RAM for infrastructure components. A single worker can host multiple application pods when its requests and placement allow — and its loss then affects all of them; there is no guaranteed one-pod-per-node placement. Worker size, count and zones are your platform administrator's settings.
Cluster admission rules must allow the installer's bounded storage-preparation Jobs and the member identity init container to run as UID 0 with only the CHOWN, FOWNER and DAC_OVERRIDE capabilities, without privileged mode, host mounts or API tokens — they are not privileged host containers. A globally enforced restricted Pod Security policy needs a reviewed, narrow exception for these helpers; the installer does not disable such a policy or grant blanket privileges.
Freeze the target cluster and native add-ons into a cloud plan
Before installation, run the plan writer shipped with the release. It reads the target cluster and writes a local cloud plan containing the provider resource ID, Kubernetes API endpoint, the kube-system namespace UID, explicit storage/network settings and the observed native add-on image references. It does not provision a cloud cluster or any cloud resource.
First list the actual native workloads, so the plan references real resources rather than conventional names:
kubectl --kubeconfig /absolute/path/kubeconfig --context CONTEXT \
-n kube-system get daemonsets,deploymentsUse actual kind/namespace/name references for the CNI and both CSI integrations, including visible node and controller components — providers do not all use identical names, and custom add-on installations replace the conventional names shown in the examples below. The plan writer requires a new output filename — it does not overwrite an existing plan, and an accepted plan must not be edited to hide platform drift. Keep the plan outside the verified release directory.
Amazon EKS
Prepare an EKS 1.34 cluster with ordinary EC2 Linux managed node groups, network policy enabled in the VPC CNI add-on, EBS CSI, EFS CSI and the AWS Load Balancer Controller. Start with fixed nodes; do not use Auto Mode, Fargate or Spot. Prepare an encrypted EFS filesystem with private mount targets, security groups and a reviewed IAM policy permitting only the installation's access points. Native CSI/controller identities need their own narrow permissions. The installer identity must be able to read the named EKS cluster and the VPC-CNI add-on, as well as perform the Kubernetes installation. Select --architecture arm64 for Graviton node groups or amd64 for x86, with the matching installer ZIP.
Write a shared-parameters file using your EFS filesystem ID (the value below is an example):
{"fileSystemId":"fs-0123456789abcdef0"}From the extracted release root, freeze the plan. Account, region, resource IDs, context, subnets and the source CIDR below are all examples — substitute your actual values. 203.0.113.10/32 is a documentation address: use your real permitted client range, and choose subnets appropriate to the internal or public scheme:
python3 deployment/cloud-profiles/prepare_plan.py \
--profile aws-eks-v1 --namespace etlworks \
--kubeconfig /absolute/etlworks-private/eks.kubeconfig --context EKS_CONTEXT \
--resource-id arn:aws:eks:us-east-1:123456789012:cluster/YOUR_CLUSTER \
--location us-east-1 --architecture amd64 \
--shared-parameters ../etlworks-private/aws-shared.json \
--source-range 203.0.113.10/32 --scheme internet-facing \
--subnet subnet-0123456789abcdef0 --subnet subnet-0123456789abcdef1 \
--addon daemonset/kube-system/aws-node \
--addon deployment/kube-system/ebs-csi-controller \
--addon daemonset/kube-system/ebs-csi-node \
--addon deployment/kube-system/efs-csi-controller \
--addon daemonset/kube-system/efs-csi-node \
--addon deployment/kube-system/aws-load-balancer-controller \
--output ../etlworks-private/cloud-plan.jsonFor internal-only access choose --scheme internal (the default when omitted) and private subnets. Installation creates a Service named CLUSTER_NAME-public: an NLB-backed TCP 443 Service to HAProxy using IP targets. Point application DNS at the advertised endpoint and establish frontend certificate trust separately. The EFS filesystem and access points, EBS volumes, the NLB and the workers are your cloud resources: their costs and retention continue after application pods are deleted.
Azure AKS
Prepare an AKS cluster with ordinary Linux VMSS node pools, enforced network policy, the managed Files and Disk CSI drivers and a Standard Load Balancer. This profile uses manually configured ordinary node pools, not node auto-provisioning. Prepare the storage account and network for Premium Azure Files NFS with encryption in transit, and use an eligible supported Linux node image. Important: do not disable encryption in transit to work around a mount failure. Subscription provider registration, identity/RBAC and sufficient regional/SKU quotas are platform tasks; the installer performs no API registration.
Write a reviewed shared-parameters file (example values):
{"storageAccount":"YOUR_STORAGE_ACCOUNT","resourceGroup":"YOUR_STORAGE_RESOURCE_GROUP"}Set the add-on variables below to actual workload references from your cluster's kube-system inventory — they are not fixed Azure add-on names:
python3 deployment/cloud-profiles/prepare_plan.py \
--profile azure-aks-v1 --namespace etlworks \
--kubeconfig /absolute/etlworks-private/aks.kubeconfig --context AKS_CONTEXT \
--resource-id /subscriptions/YOUR_SUBSCRIPTION/resourceGroups/YOUR_RESOURCE_GROUP/providers/Microsoft.ContainerService/managedClusters/YOUR_CLUSTER \
--location eastus --architecture amd64 \
--shared-parameters ../etlworks-private/azure-shared.json \
--source-range 10.20.0.0/16 --scheme internal \
--addon "$AKS_CNI_REF" \
--addon "$AKS_FILES_NODE_REF" \
--addon "$AKS_DISK_NODE_REF" \
--output ../etlworks-private/cloud-plan.jsonAdd other visible native controller components with repeated --addon, as your cluster's inventory shows them. Use your actual Azure location, subscription, resource groups and a real permitted client CIDR — the example range is not a rule to admit every private network. Azure shared and backup claims default to at least 100 GiB each; review the associated quota and cost. The cloud Service sends TCP 443 through the Standard Load Balancer to HAProxy; DNS and trusted frontend TLS remain your responsibility.
Google GKE Standard
Prepare a GKE Standard cluster with ordinary Linux node pools, enforced network policy, the Filestore and PD CSI drivers, the required Google APIs and private service access. GKE/Filestore API enablement, IAM, the gcloud/kubectl authentication plugin and quotas are platform tasks. Do not use Autopilot or preemptible/Spot nodes with this profile.
Write the shared-parameters file using your actual private network:
{"network":"projects/YOUR_PROJECT/global/networks/YOUR_PRIVATE_NETWORK"}Set the add-on variables to actual inventory references, then freeze the plan. Use the actual regional or zonal location consistently in both the resource ID and --location:
python3 deployment/cloud-profiles/prepare_plan.py \
--profile gcp-gke-standard-v1 --namespace etlworks \
--kubeconfig /absolute/etlworks-private/gke.kubeconfig --context GKE_CONTEXT \
--resource-id projects/YOUR_PROJECT/locations/us-central1/clusters/YOUR_CLUSTER \
--location us-central1 --architecture amd64 \
--shared-parameters ../etlworks-private/gcp-shared.json \
--source-range 10.20.0.0/16 --scheme internal \
--addon "$GKE_CNI_REF" \
--addon "$GKE_FILESTORE_NODE_REF" \
--addon "$GKE_PD_NODE_REF" \
--output ../etlworks-private/cloud-plan.jsonImportant: the initial Basic Filestore defaults request 1 TiB each for application data and the separately mounted backup destination. Review quota and cost before installation. The mounted backup destination is not an off-cluster backup strategy. GKE identity and provisioned Redis disks request at least 10 GiB to meet the provider disk minimum; these are storage minima, separate from licensed application RAM.
Storage security: this baseline uses private Filestore and provider network encryption. It does not provide NFS protocol-level encryption or NFS client authentication. If your security policy requires those properties, do not use this baseline; arrange a separately supported storage configuration. The installer does not introduce Active Directory or Kerberos.
The GKE profile creates an internal or external passthrough TCP 443 load-balancer Service to HAProxy, according to the selected scheme.
Configure and install using the cloud plan
Keep the ordinary signed setup, hostname, initial administrator and explicit kubeconfig/context fields described in the main guide's configuration section. Replace the local storage object and add the selected platform profile. For AWS, for example:
"platformProfile": "aws-eks-v1",
"storage": {"cloudPlan": "/absolute/etlworks-private/cloud-plan.json"}This is a JSON fragment, not a complete file. For AKS or GKE, use that profile's exact ID. Do not combine cloudPlan with workerA, workerB or retainedPlan. Use the same namespace and architecture as the frozen plan. Select PostgreSQL and Redis modes independently; for external services, follow the external-service requirements and the Secret checkpoint procedure in the main guide.
Run the usual release commands — no separate cloud switch and no hand-built Helm deployment:
sh deployment/installer/etlworks-kubernetes.sh preflight \
--config ../etlworks-private/install.json --json
sh deployment/installer/etlworks-kubernetes.sh install \
--config ../etlworks-private/install.json --wait 30m --json
sh deployment/installer/etlworks-kubernetes.sh status \
--config ../etlworks-private/install.json --json
sh deployment/installer/etlworks-kubernetes.sh resume \
--config ../etlworks-private/install.json --wait 30m --jsonPreflight reads the provider and Kubernetes identities, version and architecture, CNI policy, native CSI and the ready add-on image references against the frozen plan. It performs no writes, so cloud storage and load-balancer charges begin only when installation is explicitly requested. Installation creates retained CSI classes and claims and bounded consumer Jobs; block volumes use placement-aware binding, which can wait for a consumer.
Network access to the installed application
Each cloud profile creates a Layer 4 TCP 443 Service to HAProxy through the provider's load balancer: an NLB on EKS, the Standard Load Balancer on AKS and a passthrough load balancer on GKE. The scheme (internal or internet-facing/external) comes from the frozen plan; the default is internal. Find the advertised endpoint:
kubectl --kubeconfig /absolute/etlworks-private/kubeconfig --context CONTEXT \
-n etlworks get service etlworks-publicThe example assumes clusterName: etlworks; the Service is otherwise named CLUSTER_NAME-public. Set the application DNS name to the Service's advertised endpoint or address and establish trusted HAProxy frontend HTTPS separately. Creating the Service does not configure DNS or issue a browser-trusted certificate, and it does not expose installer, lifecycle, database or admin ports. The source range recorded in the plan restricts which client networks the load balancer admits.
If you place an additional reverse proxy in front of the application, preserve the hostname and forwarded scheme and allow the application's long-lived notification and listener traffic; see the main guide's network behavior section for the timeout and keepalive profile.
Cloud storage identity, holds and retries
Private identity claims are exclusive to one pod: 1 GiB on EBS, 4 GiB on Azure Disk and 10 GiB on GKE balanced PD, as persistent infrastructure disks separate from the signed application pod CPU/RAM. A member's logical identity and recorded volume binding survive normal CSI device-name changes; arbitrary replacement volumes are not adopted. The installer prepares fresh volume roots only — its short-lived helpers do not format or recursively change ownership of populated data. Known missing or changed volume identities cause a hold, and admission policies block ordinary claim/PV deletion and CSI identity replacement.
When storage is pending, inspect CSI events, PVC/PV bindings and the exact consumer Job, then resume the same operation. After fixing a failed helper's underlying cause, an explicit resume allows one new attempt per storage role for that invocation, with a maximum of eight retained attempts — and only after the previous worker is confirmed terminated; a timeout or an unreachable possible writer is not that evidence. Failed Jobs remain available for inspection. Do not delete known claims, delete and recreate retained claims to start over, change context or rename the installation to bypass a hold.
Cloud operations: scaling, upgrades, workers and teardown
Day-two operations are the same durable operations as on every profile — use the main guide's automatic scaling, monitoring, upgrades, pod size changes, backup and recovery and logs sections. Cloud-specific points:
- Worker capacity. Approving a larger pod size in licensing does not enlarge workers: before a pod size change, verify node-pool requested-resource headroom and storage topology for the target size.
- Worker maintenance. Coordinate voluntary disruption — node-pool changes, VM resizes, node upgrades — with Etlworks drain protection. Changing a node pool or VM is separate from application scaling and resizing, provider maintenance deadlines are finite, and a forced node loss never authorizes automatic replay of business executions.
- Node autoscaling. A provider autoscaler, where your platform administrator configures one, may add or remove workers separately; these profiles do not enable or manage it.
- Backups. Take the full offline archive and keep an independent protected copy; retained CSI volume identities remain required at restore. A provider volume snapshot alone does not prove a consistent complete PostgreSQL/Redis/application-data checkpoint.
- Teardown. Deleting an application pod, the namespace or a Helm release does not delete retained volumes, EFS/Filestore/Files shares, load balancers or workers. Plan an explicit administrator cleanup after writers stop and backups are retained — the installation's storage protection policies must be deliberately removed by an administrator, and there is no destructive cleanup-everything shortcut.
Java runtime and worker architecture
The Java runtime runs inside the managed release's application image on your workers, so JVM security exposure — for example CVE-2026-114938 (Java4Shell) in Etlworks — depends on the actual node pools the application pods land on, not on the provider name or your workstation:
- ARM64 worker pools — AWS Graviton instances on EKS, Ampere- or Cobalt-based VM sizes on AKS, and Tau T2A or Axion machine types on GKE — are not exposed to that CVE.
- x86-64 worker pools on any of the three providers must be checked for the affected CPU features and Java build. Verify the actual node pools and pod placement (kubectl get nodes -L kubernetes.io/arch with your context), then the Java build on every application pod.
Java updates ship inside the managed release's application image, and the managed release owns the JVM settings in the application pods: follow the shared procedure in Update the Java runtime, which covers the inventory checks, the UI and CLI upgrade, and the per-pod verification. Do not patch worker nodes, edit pods, or add JVM arguments outside the managed operation.
Backups and recovery on cloud profiles
Backups and restore follow the main guide's backup, restore and migration section. On cloud profiles, recovery additionally checks the recorded CSI storage identities. A same-installation restore is not an automatic clean-cluster disaster rebuild, and an upgrade or restore cannot convert the installation to another provider, profile or service mode — cross-profile moves are an explicit migration with full backup, held import, identity reconciliation and reviewed cutover. A cloud-mounted backup claim is staging, not an independent recovery copy: copy the complete archive to an independent storage failure domain and verify it.
Cloud troubleshooting
| Reported condition | Check and next action |
|---|---|
| Cloud profile/module missing from the archive | Obtain the matching 10.0.14-or-newer release and architecture. Do not edit an old release descriptor or add an invented --cloud flag. |
| CLOUD_API_SERVER_CHANGED, CLOUD_KUBERNETES_UID_CHANGED or provider target mismatch | Check the explicit context, API endpoint and provider resource ID against the frozen plan. Do not redirect an existing resume to another cluster or adopt a different cluster. |
| NATIVE_ADDON_VERSION_CHANGED or a native add-on not ready | Compare the frozen plan with the actual native workload references and rollout — this is platform drift. Resolve platform maintenance first; do not edit the accepted plan, overwrite CNI/CSI or hide a version change. |
| CLOUD_STORAGE_PENDING | Wait and read CSI events, provisioner permissions, mount networking and the exact consumer Job; resume the same operation when the dependency settles. Placement-aware binding can legitimately wait for a consumer. |
| Failed cloud storage probe or unresolved prior worker | Diagnose the retained Job. Retry only through the supported explicit resume path after exact worker exit; investigate attempt-limit holds rather than bypassing them. Do not delete or recreate retained claims to make installation start over. |
| EKS: EFS mount or IAM failure | Check private mount targets, the security-group path from workers, the scoped CSI identity and access-point IAM policy, and the TLS/IAM mount settings. |
| AKS: Azure Files share failure | Check NFS and encryption-in-transit support of the selected storage account and node image, subscription provider registration, network path and quota. Do not disable the required encryption. |
| GKE: Filestore failure | Check the Filestore API, private service access and network, the CSI add-on and per-share minimum capacity/quota. The requested file-service capacity is storage, not the pod's licensed RAM. |
| Load balancer has no endpoint, or the hostname is unreachable | Inspect the native load-balancer controller's permissions and events, the subnet/scheme selection, the permitted client CIDR, application health/readiness, DNS and the certificate chain. DNS and certificate trust are separate from Service creation. |
| Larger pods Pending after a size change | Check worker requested-resource headroom and storage topology for the target size. Approving a size in licensing does not enlarge workers. |
For platform preparation, the providers' own documentation is current and authoritative: Amazon EFS CSI driver, AWS Load Balancer Controller Service annotations, Azure Files volumes on AKS and GKE Filestore CSI driver. The Etlworks plan commands above read your cluster; they do not provision it.