FME Flow: 2025.1

Deploying to Google Cloud Using Google Kubernetes Engine and Cloud Filestore

The following steps explain how to deploy an FME Flow Kubernetes deployment consisting of multiple FME Flow Core nodes to Google Cloud using Google Kubernetes Engine (GKE) and Cloud Filestore for storage.

  1. Launch the Cluster
    1. Navigate to the Google Kubernetes Engine section of the Google Cloud Platform console.
    2. Select Create Cluster to deploy a new Kubernetes Cluster.
    3. If not already selected, select Switch to Standard cluster at the top right, and set the following parameters:
      • Name: Name of the cluster.
      • Location type: For test purposes, select Zonal.
      • Zone: Select the zone closest to you or your data.
      • Node pool: For each FME Flow Core you want to run, you need approximately 8GB of memory. For a single-Core deployment, we recommend 2 vCPUS, 8GB RAM, and 2 nodes. For a two-Core deployment, we recommend 4 vCPUs, 16GB RAM, and 3 nodes.
        • Note  More than one Core container requires a minimum of two nodes due to a constraint in the Helm chart that prevents Core containers residing on the same node. To ensure fault tolerance, we recommend three nodes because if a node is lost, two Cores can still run on the remaining two nodes.
    4. Click Create.
    1. Navigate to the Google Kubernetes Engine section of the Google Cloud Platform console.
    2. Select Create Cluster to deploy a new Kubernetes Cluster.
    3. If not already selected, select Switch to Autopilot cluster at the top right, and set the following parameters:
      • Name: Name of the cluster.
      • Region: Select the region closest to you or your data.
      • Networking: Choose the correct network settings for your environment. You must ensure that the cluster is accessible to any other services you may use, such as Filestore or Cloud SQL.
    4. Click Create.
    Note  When creating an Autopilot cluster, you may run into issues concerning resource requests. Ensure you update the resource requests before installing FME Flow to comply with the allowed minimum and maximum values. For more information, see Resource requests in Autopilot.
  2. Connect to the Cluster

    3. Run the following commands in Cloud Shell (recommended). Alternatively, configure your local machine to run kubectl and helm commands to deploy resources to the cluster.

    1. Click Connect beside the Kubernetes cluster you just launched.
    2. Copy the "Command-line access" command and run in Google Cloud Shell or execute it on your terminal.
    3. To check if you are connected to the cluster, run:

      4. kubectl get nodes

      You should see all nodes in the cluster.

    4. Install the NGINX ingress controller:

      5. kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-<version>/deploy/static/provider/cloud/deploy.yaml

      Replace <version> with the most recent version in the corresponding script in the NGINX Ingress Controller Installation Guide. As well, replace other syntax elements with any changes in the updated script.

  3. Set Up Shared Storage for the FME Flow System Share

    4. Using Cloud Filestore, storage for the FME Flow System Share is accessible across all nodes. This procedure allows your cluster to utilize the Filestore CSI driver to provision and connect to Cloud Filestore.

    1. Enable the Cloud Filestore API and the Google Kubernetes Engine API for your account, if you have not done so already: https://cloud.google.com/filestore/docs/csi-driver#prerequisites
    2. Enable the Filestore CSI driver for your cluster: https://cloud.google.com/filestore/docs/csi-driver#existing
    3. Determine which storage class you want to use based on your desired storage tier. For this guide, we use the standard tier and associated storage class standard-rwx: https://cloud.google.com/filestore/docs/csi-driver#storage-class
    4. Your cluster is now ready to provision and connect to Cloud Filestore. See the parameters table (below) for how to use Filestore with your deployment.
  4. Deploy FME Flow
    1. Add the Safe Software Helm repository:

      2. helm repo add safesoftware https://safesoftware.github.io/helm-charts/

    2. Get the IP address of the Ingress Controller:

      3. kubectl -n ingress-nginx get svc

      Note the "EXTERNAL-IP" of the "ingress-nginx-controller". This is the ingress to the cluster. In a production environment, set up a DNS that points to this IP address and use that as the hostname when deploying FME Flow. In this procedure, we access FME Flow directly using the IP.

    3. Create a namespace in which to deploy. Run:

      4. kubectl create namespace <namespace_name>

      For example:

      kubectl create namespace fmeflow

    4. Create a values.yaml file that will pass user-supplied parameter values into the Helm chart.

      5. To get the default Helm chart values file, run:

      helm show values <chart>

      For example:

      helm show values safesoftware/fmeflow

      To write the values to a file:

      helm show values safesoftware/fmeflow >> values.yaml

      For more information on value files, see the Helm Docs.

      A current list of supported parameters for FME Flow can be found on GitHub.

    5. Update parameters in values.yaml.

      6. Parameter

      Example or Possible Value

      Description
      fmeflow.image.tag 2024.2.2-20250115 Set to a valid date-stamped tag from Docker Hub (https://hub.docker.com/r/safesoftware/fmeflow-core/tags), such as 2024.2.2-20250115
      fmeflow.engines[].name “standard-group” The name of the engine group. This can be changed, particularly if creating multiple engine groups.
      fmeflow.engines[].engines 2 Controls the number of engine pods to start.
      fmeflow.engines[].type STANDARD | DYNAMIC Controls the type of engine to start.
      fmeflow.healthcheck.liveness.initialDelaySeconds 60 For Autopilot clusters, set this value to 900, as FME Flow pods take longer to come online when using Autopilot. This will ensure the pods have enough time to start without premature health checks.
      fmeflow.healthcheck.readiness.initialDelaySeconds 60 For Autopilot clusters, set this value to 900, as FME Flow pods take longer to come online when using Autopilot. This will ensure the pods have enough time to start without premature health checks.
      deployment.hostname   If a DNS has been configured to point to the external IP address, set to that value. If using the external IP address only, leave leave as localhost and set deployment.useHostnameIngress to false.
      deployment.numCores 2 Starts two FME Flow Core pods for fault tolerance and load balancing.
      deployment.useHostnameIngress true | false If DNS is set up for the ingress controller, specify the DNS name for deployment.hostname and leave this parameter to true. If not, specify false.
      storage.fmeflow.class standard-rwx The storage class for the Cloud Filestore CSI driver.
      storage.fmeflow.accessMode ReadWriteMany Set to ReadWriteMany if using Cloud Filestore with the CSI driver.

      The following resource requests have been configured to comply with minimum resource requests allowed by Autopilot.

      Note  Autopilot may automatically increase resource requests for some pods. Autopilot rejects pods that have anti-affinity rules and do not meet the minimum or allowed resource request values.

      For more information, see Resource requests in Autopilot.

      Note  The following resource request values are appropriate for a single FME Flow Core, single FME Engine deployment on Autopilot.

      Copy 
      engines:
          groups:
            - name: "standard-group"
              resources:
                requests:
                  memory: 512Mi
                  cpu: 250m
      Copy 
      resources:
        core:
          requests:
            memory: 1.5Gi
            cpu: 250m
        web:
          requests:
            memory: 1Gi
            cpu: 250m
          limits:
            memory:
            cpu:
        queue:
          requests:
            memory: 512Mi
            cpu: 500m
        websocket:
          requests:
            memory: 512Mi
            cpu: 250m
      Copy 
      postgresql:
        primary:
          persistence:
            existingClaim: fmeserver-postgresql
          resources:
            requests:
              memory: 512Mi
              cpu: 250m

    6. Install FME Flow.

      7. helm install <name> <chart> -f values.yaml -n <namespace>

      For example:

      helm install fmeflow safesoftware/fmeflow -f values.yaml -n fmeflow

      If you make changes to the values.yaml file after FME Flow is installed (such as to scale FME Flow engines), use the helm upgrade command:

      helm upgrade <name> <chart> -f values.yaml -n <namespace>

      For example:

      helm upgrade fmeflow safesoftware/fmeflow -f values.yaml -n fmeflow

    7. To access FME Flow after it deploys, use your browser to invoke the external IP in your browser.
      Note  If you are using the external IP address, and not a DNS, to access the deployment, you must update the URLs for each of the FME Flow Web Services to that address. To update, see Services.