I know this isn't the exact approach you were going for, but I've found that creating a static IP address and explicitly passing it in tends to be easier to work with.

First, create a static IP address:

gcloud compute addresses create gke-ip --region <region>

where region is the GCP region your GKE cluster is located in.

Then you can get your new IP address with:

gcloud compute addresses describe gke-ip --region <region>

Now you can add your static IP address to your service by specifying an explicit loadBalancerIP.1

apiVersion: v1
kind: Service
metadata:
  name: gateway
spec:
  selector:
    app: gateway
  ports:
    - name: http
      port: 3000
      targetPort: 3000
      nodePort: 30000
  type: LoadBalancer
  loadBalancerIP: "1.2.3.4"

At this point, you can also hard-code it into your ConfigMap and not worry about grabbing the value from the cluster itself.

1If you've already created a LoadBalancer with an auto-assigned IP address, setting an IP address won't change the IP of the underlying GCP load balancer. Instead, you should delete the LoadBalancer service in your cluster, wait ~15 minutes for the underlying GCP resources to get cleaned up, and then recreate the LoadBalancer with the explicit IP address.

The following deployment reads the external IP of a given service using kubectl every 10 seconds and patches a given configmap with it:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: configmap-updater
  labels:
    app: configmap-updater
spec:
  selector:
    matchLabels:
      app: configmap-updater
  template:
    metadata:
      labels:
        app: configmap-updater
    spec:
      containers:
      - name: configmap-updater
        image: alpine:3.10
        command: ['sh', '-c' ]
        args:
        - | #!/bin/sh
            set -x

            apk --update add curl
            curl -LO https://storage.googleapis.com/kubernetes-release/release/v1.16.0/bin/linux/amd64/kubectl
            chmod +x kubectl

            export CONFIGMAP="configmap/global-config"
            export SERVICE="service/gateway"

            while true
            do
                IP=`./kubectl get services $CONFIGMAP -o go-template --template='{{ (index .status.loadBalancer.ingress 0).ip }}'`
                PATCH=`printf '{"data":{"API_URL": "https://%s:3000"}}' $IP`
                echo ${PATCH}
                ./kubectl patch --type=merge -p "${PATCH}" $SERVICE

                sleep 10
            done

You probably have RBAC enabled in your GKE cluster and would still need to create the appropriate Role and RoleBinding for this to work correctly.

You've got a few possibilities:

• If you really need this to be hacked into your setup, you could use a similar approach with a sidecar container in your pod or a global service like above. Keep in mind that you would need to recreate your pods if the configmap actually changed for the changes to be picked up by the environment variables of your containers.

• Watch and query the Kubernetes-API for the external IP directly in your application, eliminating the need for an environment variable.

• Adopt your applications to not directly depend on the external IP.