Deleting (dangling) forwarding-rules in gcloud - gcloud

Question

We have a script that spawns clusters ip addresses and adds dns records for test environment in google cloud using gcloud container cluster create .. etc.
Then we will kubernetes and add a loadbalancer in front of the proxy.
Also there is a script that then deletes cluster again later, and ip and dns records.
Now i just released this month my payment was double as usual and after some research i found out i paid a big amount for Network Load Balancing: Forwarding Rule Additional Service Charge.
I went to the Networking > Load Balancing > Forwarding rules and here i see tons of forwarding rules forwarding to clusters that not even exist anymore. but these forwarding rules (that I never explicitly created, only indirectly through kubectl is suppose) are now still here.
The problem is i also have some which are actually in use and should not be removed. is there any way I Can filter on dangling forwarding rules i tried it but i couldn't find a way to manually do this.
I tried:
gcloud compute forwarding-rules list
gcloud compute forwarding-rules list --filter=dangling #returns nothing
gcloud compute target-pools list

Answer 1

To make sure gcloud no longer lets us pay for things they forget to delete i made a simple node script that removes dangling artifacts from the compute part of gcloud:
I'm not sure if its watertight because i shortcut forwarding-rules and target-pools references.
missing parts in this script (you'd have to implement):
const Promise = require('bluebird')
Extension method lastItem() on Array.prototype
cmd.executeDirect() => child_process.execFile() in a Promise.
script:
/**
* Remove left over compute items indirectly created by kubernetes but not removed automatically
*/
deleteDanglingComputeItems() {
return this.getComputeInstances()
.then(instances => {
var dict = {};
instances.forEach(x => dict[x.name] = true);
var killPoolsPromise = this.getComputeTargetpools()
.filter(pool => !pool.instances.some(inst => dict[inst.split("/").lastItem()] === true))
.then(pools => {
var poolDict = {};
pools.forEach(x => poolDict[x.name] = true)
return this.getComputeForwardingRules()
.filter(rules => poolDict[rules.target.split('/').lastItem()] === true)
.map(rule => this.deleteComputeForwardingRule(rule.name, rule.region))
.then(() => pools);
})
.map(pool => this.deleteComputeTargetpool(pool.name, pool.region))
var firewallPromise = this.getComputeFirewallRules()
.filter(rule => rule.targetTags && !rule.targetTags.some(target => dict[target] === true))
.then(rules => this.deleteFirewallRules(rules.map(x=> x.name)))
//Todo add firewall
return Promise.all([killPoolsPromise, firewallPromise]);
});
}
getComputeInstances() {
return this._execJson(['compute', 'instances', 'list']);
}
getComputeTargetpools() {
return this._execJson(['compute', 'target-pools', 'list'])
}
getComputeForwardingRules() {
return this._execJson(['compute', 'forwarding-rules', 'list'])
}
getComputeFirewallRules() {
return this._execJson(['compute', 'firewall-rules', 'list'])
}
deleteComputeTargetpool(pool, region) {
return this._execJson(['compute', 'target-pools', 'delete', pool, '--region', region])
}
deleteComputeTargetpools(pools = []) {
if (pools.length === 0)
return Promise.resolve();
return this._execJson(['compute', 'target-pools', 'delete', ...pools])
}
deleteComputeForwardingRule(rule, region) {
return this._execJson(['compute', 'forwarding-rules', 'delete', rule, '--region', region])
}
deleteFirewallRules(rules = []) {
if (rules.length === 0)
return Promise.resolve();
return this._execJson(['compute', 'firewall-rules', 'delete', ...rules])
}
/**
* #param {string[]} parameters
* #param {ExecFileOptions} options
*/
_exec(parameters, options) {
return cmd.get('gcloud', parameters, options);
}
/**
* #returns {Promise} with result data.
*/
_execJson(parameters, optionFlags = {}, cmdOptions) {
return this._exec(parameters.concat(this._generateFlags(optionFlags)), cmdOptions)
.promise
.tap(c => { log.debug(c.stderr); log.debug(c.stdout); })
.then(x => JSON.parse(x.stdout));
}