Migrating PVC Data and Ingress from Geddes to Geddes2¶
This guide covers persistent volume claim (PVC) data migration and application ingress migration from Geddes to Geddes2.
Overview¶
The migration process consists of the following steps:
- Configure the Geddes and Geddes2 kubectl contexts (see Migrating Namespaces and Workloads)
- Export PVC YAML definitions from Geddes
- Clean and update PVC YAML files
- Prepare the destination environment on Geddes2
- Deploy the migration toolbox on Geddes and Geddes2
- Launch the destination toolbox on Geddes2 and transfer data
- Clean up resources and restart applications
Prerequisites¶
Before starting the migration:
- Ensure you have access to both Geddes and Geddes2 clusters
- Ensure
kubectlis installed and configured -
Ensure you have permissions to:
- View PVCs
- Create deployments and services
- Scale workloads
- Create secrets
Step 1 — Configure kubectl Contexts¶
Configure the Geddes and Geddes2 kubectl contexts (see Migrating Namespaces and Workloads).
Step 2 — Export PVC YAML from Geddes¶
You can export PVC definitions using either the provided export utility script or standard kubectl commands.
Option A — Use the Export Utility Script (Recommended)¶
See the export resources utility script documented in Migrating Namespaces and Workloads.
Option B — Use kubectl Commands¶
List PVCs in Your Namespace¶
Example output:
Export the PVC YAML¶
Step 3 — Clean Up PVC YAML Before Deployment¶
Before deploying the PVC to Geddes2, the YAML file must be cleaned and updated.
Clean the YAML File¶
Use the cleanup utility in Migrating Namespaces and Workloads. Review its documented behavior before running it; the multiple-file cleanup script overwrites files in place.
Update the StorageClass Name¶
Important
Before deploying the PVC YAML to Geddes2, you must update the storageClassName to match an available storage class on Geddes2.
To view available storage classes on Geddes2:
Open the exported YAML file and replace:
with:
Use the appropriate storage class assigned to your project. If you are unsure which storage class to use, contact:
rcac-help@purdue.edu
Step 4 — Prepare the Geddes2 Environment¶
Before transferring data, prepare the destination environment on Geddes2.
Scale Down Applications on Geddes2¶
The destination PVC must not be mounted or in use during migration.
Scale Down Applications on Geddes¶
To prevent data corruption, stop workloads on the source cluster before migration.
Step 5 — Deploy the Migration Toolbox on Geddes¶
Deploy the rsync migration toolbox on the source cluster.
1. Create the SSH Password Secret¶
2. Deploy the Migration Toolbox¶
Update OLD_PVC_NAME_HERE and <YOUR-NAMESPACE> before deployment.
Apply the YAML:
3. Retrieve the Source IP Address¶
Wait until the EXTERNAL-IP is assigned.
This IP address will be used as the source endpoint during the rsync transfer.
Step 6 — Launch the Destination Toolbox and Transfer Data¶
Deploy the same toolbox YAML on Geddes2.
Ensure that:
claimNamereferences the new PVC names on Geddes2- The namespace matches your project my-namespace
1. Create the SSH Password Secret¶
2. Deploy the Toolbox on Geddes2¶
3. Enter the Destination Toolbox Pod¶
4. Run the Rsync Transfer¶
Replace SOURCE_IP_HERE with the external IP obtained earlier.
Verification and confirm that data exists before rsync.
If you are satisfied with the ls and du output, you can run rsync:
Tip
If migrating multiple PVCs, run a separate rsync command for each mounted directory.
Step 7 — Cleanup and Restart Applications¶
Delete the Migration Toolbox Resources¶
IMPORTANT: Use a strong temporary password and delete the migration toolbox immediately after migration is complete.
Run these commands on both Geddes and Geddes2:
-
Geddes
-
Geddes2
PVC validation¶
- PVCs are Bound
- Application pods are Running
- Data exists on Geddes2
Scale Applications Back Up on Geddes2¶
Your application should now be running on Geddes2 with migrated data.
Migrating Multiple PVCs¶
If your application uses multiple PVCs (for example: config, data, and logs), you can mount them all into the same migration toolbox deployment.
Example: Multiple PVC Volume Mounts¶
Add the following under the containers section:
Add the following under spec.template.spec:
Multi-PVC Rsync Commands¶
Run one rsync command per mount point.
Note
Ensure you include trailing slashes (/) so the contents of the directories are copied correctly.
Additional Notes¶
- Ensure workloads remain scaled down during the entire migration process
- Verify PVC capacity and storage class compatibility before deployment
- Test applications after migration before removing old resources
- Keep backups of important data before starting the migration process
Migrating Ingress from Geddes to Geddes V2¶
Exposing Applications Using Traefik and Gateway API¶
Purpose: This guide explains how to expose applications running in Kubernetes on Geddesv2 using Traefik and Kubernetes Gateway API.
It also provides instructions for users migrating applications from the original Geddes cluster, which uses NGINX Ingress.
1. Overview: Geddes vs. Geddesv2¶
The original Geddes cluster and Geddesv2 use different ingress technologies.
| Feature | Geddes (Old) | Geddesv2 (New) |
|---|---|---|
| Ingress controller | NGINX Ingress | Traefik |
| Routing resource | Ingress | HTTPRoute |
| Configuration | NGINX annotations | Gateway API |
| Advanced routing | NGINX annotations | Gateway API filters / Traefik Middleware |
| TLS termination | NGINX Ingress | Traefik Gateway |
Why are we moving away from NGINX Ingress?¶
The community Kubernetes Ingress NGINX project reached End of Life (EOL) in March 2026.
Following its retirement, the project no longer receives security updates, bug fixes, or maintenance releases.
For this reason, Geddesv2 uses Traefik with Kubernetes Gateway API as the replacement for the old NGINX Ingress infrastructure.
This also provides a more standardized approach to managing application routing.
2. Available Gateways on Geddesv2¶
Geddesv2 provides two Traefik Gateway endpoints for application access.
| Gateway | Namespace | Access |
|---|---|---|
| Private | traefik-private |
Purdue campus network and VPN |
| Public | traefik-public |
Public Internet |
Users must select the appropriate Gateway when creating an HTTPRoute.
Private Gateway:
Public Gateway:
The Gateway infrastructure is managed by cluster administrators. Users do not need to deploy their own Gateway or Traefik instance.
3. Creating an HTTPRoute on Geddesv2¶
The recommended way to expose an application is by creating an HTTPRoute.
Example: Exposing an application¶
Suppose you have an application running in the following namespace:
- Namespace:
my-app-namespace - Service name:
my-app - Service port:
8080
Create a file named my-app-httproute.yaml:
Apply the configuration:
Verify the HTTPRoute:
Check its status:
Look for these conditions:
Accepted: TrueResolvedRefs: True
Once the route is accepted and the backend is correctly configured, the application should be accessible at:
https://my-app.geddes.rcac.purdue.edu
Public application example¶
If the application needs to be accessible from the public Internet, change the parent reference to:
The rest of the HTTPRoute configuration remains the same.
4. Understanding the HTTPRoute Configuration¶
| Field | Description |
|---|---|
metadata.name |
Name of the HTTPRoute |
metadata.namespace |
Namespace containing the application |
parentRefs.name |
Name of the Gateway |
parentRefs.namespace |
Namespace containing the Gateway |
sectionName |
Gateway listener to use (https) |
hostnames |
DNS hostname assigned to the application |
matches.path.value |
URL path to match |
backendRefs.name |
Kubernetes Service name |
backendRefs.port |
Kubernetes Service port |
Important: The parentRefs.namespace field is required when the Gateway is in a different namespace from the HTTPRoute.
For example, an HTTPRoute in my-app-namespace references a Gateway in traefik-private. Therefore, the Gateway namespace must be specified.
If the Gateway were in the same namespace as the HTTPRoute, the namespace field could be omitted.
5. Migrating from NGINX Ingress to Traefik¶
Existing applications on the original Geddes cluster may use Kubernetes Ingress resources and NGINX-specific annotations.
When migrating applications to Geddesv2, there are two possible approaches.
Option A: Convert NGINX Ingress to HTTPRoute (Recommended)¶
This is the recommended approach for new and migrated applications.
Example of an existing NGINX Ingress:
The equivalent basic routing configuration on Geddesv2:
Notice that the NGINX-specific annotations are no longer present.
Some NGINX functionality has an equivalent in Gateway API, while other functionality requires Traefik Middleware resources or additional configuration.
Option B: Continue Using Kubernetes Ingress¶
Traefik can also support standard Kubernetes Ingress resources if its Kubernetes Ingress provider is enabled.
However, this is not the recommended approach for new deployments.
Considerations:
- The Ingress must use the appropriate Traefik IngressClass.
- NGINX-specific annotations will not work with Traefik.
- Traefik-specific annotations may be required for certain features.
- Existing NGINX configurations must be reviewed and tested.
For long-term compatibility and consistency, use HTTPRoute.
6. Common NGINX Annotation Replacements¶
Not every NGINX annotation has a direct equivalent in Gateway API.
| NGINX annotation | Geddesv2 alternative |
|---|---|
ssl-redirect |
Gateway API RequestRedirect filter or HTTPS Gateway configuration |
rewrite-target |
Gateway API URLRewrite filter |
proxy-body-size |
Traefik Middleware / buffering configuration |
proxy-read-timeout |
Gateway API timeouts or Traefik-specific configuration |
proxy-send-timeout |
Traefik-specific configuration |
whitelist-source-range |
Traefik IPAllowList Middleware |
proxy-buffering |
Traefik-specific configuration |
auth-url |
Traefik ForwardAuth Middleware |
configuration-snippet |
Traefik Middleware or another supported configuration mechanism |
Migration should be evaluated individually because some NGINX features do not have a direct Gateway API equivalent.
7. Using Traefik Middleware¶
For functionality that is not available through standard Gateway API filters, Traefik provides Middleware resources.
For example, to configure IP-based access restrictions, create a Middleware:
Then reference the Middleware from your HTTPRoute:
This allows users to retain functionality such as IP restrictions while using Gateway API routing.
Note that the Middleware CRD must be installed, and the Traefik Gateway provider must support the referenced extension.
8. Troubleshooting¶
If your application is not accessible after creating an HTTPRoute, check the following.
Step 1: Verify the HTTPRoute¶
Step 2: Check HTTPRoute conditions¶
Look for:
Accepted: TrueResolvedRefs: True
Step 3: Verify the Gateway¶
Private:
Public:
Step 4: Verify the Kubernetes Service¶
Make sure the backend Service name and port match your HTTPRoute configuration.
Step 5: Verify application endpoints¶
Make sure the application has healthy backend endpoints.
Step 6: Contact Geddes Cluster Administrators for Help¶
If the route is accepted but traffic is still not reaching the application, contact the cluster administrators for assistance with Traefik logs and Gateway configuration.
9. Migration Recommendations¶
When moving applications from Geddes to Geddesv2, we recommend the following process:
- Identify existing NGINX Ingress resources.
- Review all NGINX annotations currently being used.
- Identify the application hostname, Service name, and Service port.
- Create a new HTTPRoute using the appropriate Geddesv2 Gateway.
- Translate any required NGINX functionality into Gateway API filters or Traefik Middleware.
- Test the application using its assigned hostname.
- Update DNS as part of the application migration process, where necessary.
Do not assume that copying an existing NGINX Ingress YAML file to Geddesv2 will work without modification.
10. Useful Documentation¶
- Kubernetes Gateway API: https://gateway-api.sigs.k8s.io/
- HTTPRoute reference: https://gateway-api.sigs.k8s.io/reference/api-types/httproute/
- Gateway API migration from Ingress: https://gateway-api.sigs.k8s.io/guides/getting-started/migrating-from-ingress/
- Traefik Kubernetes Gateway API: https://doc.traefik.io/traefik/reference/routing-configuration/kubernetes/gateway-api/
- Traefik Middleware documentation: https://doc.traefik.io/traefik/reference/routing-configuration/http/middlewares/overview/
For assistance with application routing or migration, contact the RCAC support team at rcac-help@purdue.edu.