resource "google_compute_address" "default" {  name   = "my-test-static-ip-address"  region = "us-central1"}

resource "google_compute_global_address" "default" {  project      = var.project_id # Replace this with your service project ID in quotes  name         = "ipv6-address"  address_type = "EXTERNAL"  ip_version   = "IPV6"}

import("context""fmt""io"compute"cloud.google.com/go/compute/apiv1""cloud.google.com/go/compute/apiv1/computepb")// reserveNewRegionalExternal reserves a new regional external IP address in Google Cloud Platform.funcreserveNewRegionalExternal(wio.Writer,projectID,region,addressNamestring,isPremiumbool)(*computepb.Address,error){// projectID := "your_project_id"// region := "europe-central2"// addressName := "your_address_name"// isPremium := truectx:=context.Background()networkTier:=computepb.AccessConfig_STANDARD.String()ifisPremium{networkTier=computepb.AccessConfig_PREMIUM.String()}address:=&computepb.Address{Name:&addressName,NetworkTier:&networkTier,}client,err:=compute.NewAddressesRESTClient(ctx)iferr!=nil{returnnil,fmt.Errorf("NewAddressesRESTClient: %w",err)}deferclient.Close()req:=&computepb.InsertAddressRequest{Project:projectID,Region:region,AddressResource:address,}op,err:=client.Insert(ctx,req)iferr!=nil{returnnil,fmt.Errorf("unable to reserve regional address: %w",err)}err=op.Wait(ctx)iferr!=nil{returnnil,fmt.Errorf("waiting for the regional address reservation operation to complete: %w",err)}addressResult,err:=client.Get(ctx,&computepb.GetAddressRequest{Project:projectID,Region:region,Address:addressName,})iferr!=nil{returnnil,fmt.Errorf("unable to get reserved regional address: %w",err)}fmt.Fprintf(w,"Regional address %v reserved: %v",addressName,addressResult.GetAddress())returnaddressResult,err}// reserveNewGlobalExternal reserves a new global external IP address in Google Cloud Platform.funcreserveNewGlobalExternal(wio.Writer,projectID,addressNamestring,isV6bool)(*computepb.Address,error){// projectID := "your_project_id"// addressName := "your_address_name"// isV6 := falsectx:=context.Background()ipVersion:=computepb.Address_IPV4.String()ifisV6{ipVersion=computepb.Address_IPV6.String()}address:=&computepb.Address{Name:&addressName,IpVersion:&ipVersion,}client,err:=compute.NewGlobalAddressesRESTClient(ctx)iferr!=nil{returnnil,fmt.Errorf("NewGlobalAddressesRESTClient: %w",err)}deferclient.Close()req:=&computepb.InsertGlobalAddressRequest{Project:projectID,AddressResource:address,}op,err:=client.Insert(ctx,req)iferr!=nil{returnnil,fmt.Errorf("unable to reserve global address: %w",err)}err=op.Wait(ctx)iferr!=nil{returnnil,fmt.Errorf("waiting for the global address reservation operation to complete: %w",err)}addressResult,err:=client.Get(ctx,&computepb.GetGlobalAddressRequest{Project:projectID,Address:addressName,})iferr!=nil{returnnil,fmt.Errorf("unable to get reserved global address: %w",err)}fmt.Fprintf(w,"Global address %v reserved: %v",addressName,addressResult.GetAddress())returnaddressResult,nil}

importcom.google.cloud.compute.v1.Address;importcom.google.cloud.compute.v1.Address.AddressType;importcom.google.cloud.compute.v1.Address.IpVersion;importcom.google.cloud.compute.v1.Address.NetworkTier;importcom.google.cloud.compute.v1.AddressesClient;importcom.google.cloud.compute.v1.GlobalAddressesClient;importcom.google.cloud.compute.v1.InsertAddressRequest;importcom.google.cloud.compute.v1.InsertGlobalAddressRequest;importcom.google.common.collect.Lists;importjava.io.IOException;importjava.util.List;importjava.util.UUID;importjava.util.concurrent.ExecutionException;importjava.util.concurrent.TimeUnit;importjava.util.concurrent.TimeoutException;publicclassReserveNewExternalAddress{publicstaticvoidmain(String[]args)throwsIOException,ExecutionException,InterruptedException,TimeoutException{// TODO(developer): Replace these variables before running the sample.// Project ID or project number of the Google Cloud project you want to use.StringprojectId="your-project-id";// Address name you want to use.StringaddressName="your-address-name";// 'IPV4' or 'IPV6' depending on the IP version. IPV6 if True.booleanipV6=false;// 'STANDARD' or 'PREMIUM' network tier. Standard option available only in regional ip.booleanisPremium=false;// region (Optional[str]): The region to reserve the IP address in, if regional.// Must be None if global.Stringregion=null;reserveNewExternalIpAddress(projectId,addressName,ipV6,isPremium,region);}// Reserves a new external IP address in the specified project and region.publicstaticList<Address>reserveNewExternalIpAddress(StringprojectId,StringaddressName,booleanipV6,booleanisPremium,Stringregion)throwsIOException,ExecutionException,InterruptedException,TimeoutException{StringipVersion=ipV6?IpVersion.IPV6.name():IpVersion.IPV4.name();StringnetworkTier=!isPremium &&region!=null?NetworkTier.STANDARD.name():NetworkTier.PREMIUM.name();Address.Builderaddress=Address.newBuilder().setName(addressName).setAddressType(AddressType.EXTERNAL.name()).setNetworkTier(networkTier);// Use global client if no region is specifiedif(region==null){// Initialize client that will be used to send requests. This client only needs to be created// once, and can be reused for multiple requests.try(GlobalAddressesClientclient=GlobalAddressesClient.create()){address.setIpVersion(ipVersion);InsertGlobalAddressRequestaddressRequest=InsertGlobalAddressRequest.newBuilder().setProject(projectId).setRequestId(UUID.randomUUID().toString()).setAddressResource(address.build()).build();client.insertCallable().futureCall(addressRequest).get(30,TimeUnit.SECONDS);returnLists.newArrayList(client.list(projectId).iterateAll());}}else{// Initialize client that will be used to send requests. This client only needs to be created// once, and can be reused for multiple requests.try(AddressesClientclient=AddressesClient.create()){address.setRegion(region);InsertAddressRequestaddressRequest=InsertAddressRequest.newBuilder().setProject(projectId).setRequestId(UUID.randomUUID().toString()).setAddressResource(address.build()).setRegion(region).build();client.insertCallable().futureCall(addressRequest).get(30,TimeUnit.SECONDS);returnLists.newArrayList(client.list(projectId,region).iterateAll());}}}}

fromtypingimportOptionalfromgoogle.cloud.compute_v1.services.addresses.clientimportAddressesClientfromgoogle.cloud.compute_v1.services.global_addressesimportGlobalAddressesClientfromgoogle.cloud.compute_v1.typesimportAddressdefreserve_new_external_ip_address(project_id:str,address_name:str,is_v6:bool=False,is_premium:bool=False,region:Optional[str]=None,):"""    Reserves a new external IP address in the specified project and region.    Args:    project_id (str): Your Google Cloud project ID.    address_name (str): The name for the new IP address.    is_v6 (bool): 'IPV4' or 'IPV6' depending on the IP version. IPV6 if True.    is_premium (bool): 'STANDARD' or 'PREMIUM' network tier. Standard option available only in regional ip.    region (Optional[str]): The region to reserve the IP address in, if regional. Must be None if global.    Returns:    None    """ip_version="IPV6"ifis_v6else"IPV4"network_tier="STANDARD"ifnotis_premiumandregionelse"PREMIUM"address=Address(name=address_name,address_type="EXTERNAL",network_tier=network_tier,)ifnotregion:# global IP addressclient=GlobalAddressesClient()address.ip_version=ip_versionoperation=client.insert(project=project_id,address_resource=address)else:# regional IP addressaddress.region=regionclient=AddressesClient()operation=client.insert(project=project_id,region=region,address_resource=address)operation.result()print(f"External IP address '{address_name}' reserved successfully.")

import("context""fmt""io"compute"cloud.google.com/go/compute/apiv1"computepb"cloud.google.com/go/compute/apiv1/computepb""google.golang.org/protobuf/proto")// promoteEphemeralAddress promotes an ephemeral IP address to a reserved static external IP address.funcpromoteEphemeralAddress(wio.Writer,projectID,region,ephemeralIP,addressNamestring)error{// projectID := "your_project_id"// region := "europe-central2"// ephemeral_ip := "214.123.100.121"ctx:=context.Background()client,err:=compute.NewAddressesRESTClient(ctx)iferr!=nil{returnfmt.Errorf("NewAddressesRESTClient: %w",err)}deferclient.Close()addressResource:=&computepb.Address{Name:proto.String(addressName),AddressType:proto.String("EXTERNAL"),Address:proto.String(ephemeralIP),}req:=&computepb.InsertAddressRequest{Project:projectID,Region:region,AddressResource:addressResource,}op,err:=client.Insert(ctx,req)iferr!=nil{returnfmt.Errorf("failed to insert address promoted: %v",err)}// Wait for the operation to completeerr=op.Wait(ctx)iferr!=nil{returnfmt.Errorf("failed to complete promotion operation: %v",err)}fmt.Fprintf(w,"Ephemeral IP %s address promoted successfully",ephemeralIP)returnnil}

importcom.google.cloud.compute.v1.Address;importcom.google.cloud.compute.v1.Address.AddressType;importcom.google.cloud.compute.v1.AddressesClient;importcom.google.cloud.compute.v1.InsertAddressRequest;importcom.google.common.collect.Lists;importjava.io.IOException;importjava.util.List;importjava.util.UUID;importjava.util.concurrent.ExecutionException;importjava.util.concurrent.TimeUnit;importjava.util.concurrent.TimeoutException;publicclassPromoteEphemeralIp{publicstaticvoidmain(String[]args)throwsIOException,ExecutionException,InterruptedException,TimeoutException{// TODO(developer): Replace these variables before running the sample.// Project ID or project number of the Google Cloud project you want to use.StringprojectId="your-project-id";// Region where the VM and IP is located.Stringregion="your-region-id";// Ephemeral IP address to promote.StringephemeralIp="your-ephemeralIp";// Name of the address to assign.StringaddressName="your-addressName";promoteEphemeralIp(projectId,region,ephemeralIp,addressName);}// Promote ephemeral IP found on the instance to a static IP.publicstaticList<Address>promoteEphemeralIp(StringprojectId,Stringregion,StringephemeralIp,StringaddressName)throwsIOException,ExecutionException,InterruptedException,TimeoutException{// Initialize client that will be used to send requests. This client only needs to be created// once, and can be reused for multiple requests.try(AddressesClientclient=AddressesClient.create()){AddressaddressResource=Address.newBuilder().setName(addressName).setRegion(region).setAddressType(AddressType.EXTERNAL.name()).setAddress(ephemeralIp).build();InsertAddressRequestaddressRequest=InsertAddressRequest.newBuilder().setRegion(region).setProject(projectId).setAddressResource(addressResource).setRequestId(UUID.randomUUID().toString()).build();client.insertCallable().futureCall(addressRequest).get(30,TimeUnit.SECONDS);returnLists.newArrayList(client.list(projectId,region).iterateAll());}}}

importuuidfromgoogle.cloud.compute_v1importAddressesClientfromgoogle.cloud.compute_v1.typesimportAddressdefpromote_ephemeral_ip(project_id:str,ephemeral_ip:str,region:str):"""    Promote ephemeral IP found on the instance to a static IP.    Args:        project_id (str): Project ID.        ephemeral_ip (str): Ephemeral IP address to promote.        region (str): Region where the VM and IP is located.    """addresses_client=AddressesClient()# Create a new static IP address using existing ephemeral IPaddress_resource=Address(name=f"ip-reserved-{uuid.uuid4()}",# new name for promoted IP addressregion=region,address_type="EXTERNAL",address=ephemeral_ip,)operation=addresses_client.insert(project=project_id,region=region,address_resource=address_resource)operation.result()print(f"Ephemeral IP{ephemeral_ip} has been promoted to a static IP.")

import("context""fmt""io"compute"cloud.google.com/go/compute/apiv1""google.golang.org/api/iterator""cloud.google.com/go/compute/apiv1/computepb")// listRegionalExternal retrieves list external IP addresses in Google Cloud Platform region.funclistRegionalExternal(wio.Writer,projectID,regionstring)([]*computepb.Address,error){// projectID := "your_project_id"// region := "europe-west3"ctx:=context.Background()// Create the service client.addressesClient,err:=compute.NewAddressesRESTClient(ctx)iferr!=nil{returnnil,err}deferaddressesClient.Close()// Build the request.req:=&computepb.ListAddressesRequest{Project:projectID,Region:region,}// List the addresses.it:=addressesClient.List(ctx,req)// Iterate over the results.varaddresses[]*computepb.Addressfor{address,err:=it.Next()iferr==iterator.Done{break}iferr!=nil{returnnil,err}addresses=append(addresses,address)}// Print the addresses.fmt.Fprint(w,"Fetched addresses: \n")for_,address:=rangeaddresses{fmt.Fprintf(w,"%s\n",*address.Name)}returnaddresses,nil}// listGlobalExternal retrieves list external global IP addresses in Google Cloud Platform.funclistGlobalExternal(wio.Writer,projectIDstring)([]*computepb.Address,error){// projectID := "your_project_id"ctx:=context.Background()// Create the service client.addressesClient,err:=compute.NewGlobalAddressesRESTClient(ctx)iferr!=nil{returnnil,err}deferaddressesClient.Close()// Build the request.req:=&computepb.ListGlobalAddressesRequest{Project:projectID,}// List the addresses.it:=addressesClient.List(ctx,req)// Iterate over the results.varaddresses[]*computepb.Addressfor{address,err:=it.Next()iferr==iterator.Done{break}iferr!=nil{returnnil,err}addresses=append(addresses,address)}// Print the addresses.fmt.Fprint(w,"Fetched addresses: \n")for_,address:=rangeaddresses{fmt.Fprintf(w,"%s\n",*address.Name)}returnaddresses,nil}

importcom.google.cloud.compute.v1.Address;importcom.google.cloud.compute.v1.AddressesClient;importcom.google.cloud.compute.v1.GlobalAddressesClient;importcom.google.cloud.compute.v1.ListAddressesRequest;importcom.google.cloud.compute.v1.ListGlobalAddressesRequest;importcom.google.common.collect.Lists;importjava.io.IOException;importjava.util.List;importjava.util.concurrent.ExecutionException;importjava.util.concurrent.TimeoutException;publicclassListStaticExternalIp{publicstaticvoidmain(String[]args)throwsIOException,ExecutionException,InterruptedException,TimeoutException{// TODO(developer): Replace these variables before running the sample.// Project ID or project number of the Google Cloud project you want to use.StringprojectId="your-project-id";// Region where the VM and IP is located.Stringregion="your-region-id";listStaticExternalIp(projectId,region);}// Lists all static external IP addresses, either regional or global.publicstaticList<Address>listStaticExternalIp(StringprojectId,Stringregion)throwsIOException{// Use regional client if a region is specifiedif(region!=null){// Initialize client that will be used to send requests. This client only needs to be created// once, and can be reused for multiple requests.try(AddressesClientclient=AddressesClient.create()){ListAddressesRequestrequest=ListAddressesRequest.newBuilder().setProject(projectId).setRegion(region).build();returnLists.newArrayList(client.list(request).iterateAll());}}else{// Initialize client that will be used to send requests. This client only needs to be created// once, and can be reused for multiple requests.try(GlobalAddressesClientclient=GlobalAddressesClient.create()){ListGlobalAddressesRequestrequest=ListGlobalAddressesRequest.newBuilder().setProject(projectId).build();returnLists.newArrayList(client.list(request).iterateAll());}}}}

fromtypingimportList,Optionalfromgoogle.cloud.compute_v1.services.addresses.clientimportAddressesClientfromgoogle.cloud.compute_v1.services.global_addressesimportGlobalAddressesClientfromgoogle.cloud.compute_v1.typesimportAddressdeflist_static_ip_addresses(project_id:str,region:Optional[str]=None)->List[Address]:"""    Lists all static external IP addresses, either regional or global.    Args:    project_id (str): project ID.    region (Optional[str]): The region of the IP addresses if regional. None if global.    Returns:    List[Address]: A list of Address objects containing details about the requested IPs.    """ifregion:# Use regional client if a region is specifiedclient=AddressesClient()addresses_iterator=client.list(project=project_id,region=region)else:# Use global client if no region is specifiedclient=GlobalAddressesClient()addresses_iterator=client.list(project=project_id)returnlist(addresses_iterator)# Convert the iterator to a list to return

import("context""fmt""io"compute"cloud.google.com/go/compute/apiv1""cloud.google.com/go/compute/apiv1/computepb")// getExternalAddress retrieves the external IP address of the given address.funcgetRegionalExternal(wio.Writer,projectID,region,addressNamestring)(*computepb.Address,error){// projectID := "your_project_id"// region := "europe-west3"// addressName := "your_address_name"ctx:=context.Background()addressesClient,err:=compute.NewAddressesRESTClient(ctx)iferr!=nil{returnnil,fmt.Errorf("NewAddressesRESTClient: %w",err)}deferaddressesClient.Close()req:=&computepb.GetAddressRequest{Project:projectID,Region:region,Address:addressName,}address,err:=addressesClient.Get(ctx,req)iferr!=nil{returnnil,fmt.Errorf("unable to get address: %w",err)}fmt.Fprintf(w,"Regional address %s has external IP address: %s\n",addressName,address.GetAddress())returnaddress,nil}funcgetGlobalExternal(wio.Writer,projectID,addressNamestring)(*computepb.Address,error){ctx:=context.Background()globalAddressesClient,err:=compute.NewGlobalAddressesRESTClient(ctx)iferr!=nil{returnnil,fmt.Errorf("NewGlobalAddressesRESTClient: %w",err)}deferglobalAddressesClient.Close()req:=&computepb.GetGlobalAddressRequest{Project:projectID,Address:addressName,}address,err:=globalAddressesClient.Get(ctx,req)iferr!=nil{returnnil,fmt.Errorf("unable to get address: %w",err)}fmt.Fprintf(w,"Global address %s has external IP address: %s\n",addressName,address.GetAddress())returnaddress,nil}

importcom.google.cloud.compute.v1.Address;importcom.google.cloud.compute.v1.AddressesClient;importcom.google.cloud.compute.v1.GetAddressRequest;importcom.google.cloud.compute.v1.GetGlobalAddressRequest;importcom.google.cloud.compute.v1.GlobalAddressesClient;importjava.io.IOException;importjava.util.concurrent.ExecutionException;importjava.util.concurrent.TimeoutException;publicclassGetStaticIpAddress{publicstaticvoidmain(String[]args)throwsIOException,ExecutionException,InterruptedException,TimeoutException{// TODO(developer): Replace these variables before running the sample.// Project ID or project number of the Google Cloud project you want to use.StringprojectId="your-project-id";// Region where the VM and IP is located.Stringregion="your-region-id";// Name of the address to assign.StringaddressName="your-addressName";getStaticIpAddress(projectId,region,addressName);}// Retrieves a static external IP address, either regional or global.publicstaticAddressgetStaticIpAddress(StringprojectId,Stringregion,StringaddressName)throwsIOException{// Use regional client if a region is specifiedif(region!=null){// Initialize client that will be used to send requests. This client only needs to be created// once, and can be reused for multiple requests.try(AddressesClientclient=AddressesClient.create()){GetAddressRequestrequest=GetAddressRequest.newBuilder().setProject(projectId).setRegion(region).setAddress(addressName).build();returnclient.get(request);}}else{// Initialize client that will be used to send requests. This client only needs to be created// once, and can be reused for multiple requests.try(GlobalAddressesClientclient=GlobalAddressesClient.create()){GetGlobalAddressRequestrequest=GetGlobalAddressRequest.newBuilder().setProject(projectId).setAddress(addressName).build();returnclient.get(request);}}}}

fromtypingimportOptionalfromgoogle.cloud.compute_v1.services.addresses.clientimportAddressesClientfromgoogle.cloud.compute_v1.services.global_addressesimportGlobalAddressesClientfromgoogle.cloud.compute_v1.typesimportAddressdefget_static_ip_address(project_id:str,address_name:str,region:Optional[str]=None)->Address:"""    Retrieves a static external IP address, either regional or global.    Args:    project_id (str): project ID.    address_name (str): The name of the IP address.    region (Optional[str]): The region of the IP address if it's regional. None if it's global.    Raises: google.api_core.exceptions.NotFound: in case of address not found    Returns:    Address: The Address object containing details about the requested IP.    """ifregion:# Use regional client if a region is specifiedclient=AddressesClient()address=client.get(project=project_id,region=region,address=address_name)else:# Use global client if no region is specifiedclient=GlobalAddressesClient()address=client.get(project=project_id,address=address_name)returnaddress

import("context""fmt""io"compute"cloud.google.com/go/compute/apiv1""cloud.google.com/go/compute/apiv1/computepb")// releaseRegionalStaticExternal releases a static regional external IP address.funcreleaseRegionalStaticExternal(wio.Writer,projectID,region,addressNamestring)error{// projectID := "your_project_id"// region := "us-central1"// addressName := "your_address_name"ctx:=context.Background()addressesClient,err:=compute.NewAddressesRESTClient(ctx)iferr!=nil{returnfmt.Errorf("NewAddressesRESTClient: %w",err)}deferaddressesClient.Close()req:=&computepb.DeleteAddressRequest{Project:projectID,Region:region,Address:addressName,}op,err:=addressesClient.Delete(ctx,req)iferr!=nil{returnfmt.Errorf("unable to release static external IP address: %w",err)}iferr=op.Wait(ctx);err!=nil{returnfmt.Errorf("unable to wait for the operation: %w",err)}fmt.Fprintf(w,"Static external IP address released\n")returnnil}// releaseGlobalStaticExternal releases a static global external IP address.funcreleaseGlobalStaticExternal(wio.Writer,projectID,addressNamestring)error{// projectID := "your_project_id"// addressName := "your_address_name"ctx:=context.Background()addressesClient,err:=compute.NewGlobalAddressesRESTClient(ctx)iferr!=nil{returnfmt.Errorf("NewGlobalAddressesRESTClient: %w",err)}deferaddressesClient.Close()req:=&computepb.DeleteGlobalAddressRequest{Project:projectID,Address:addressName,}op,err:=addressesClient.Delete(ctx,req)iferr!=nil{returnfmt.Errorf("unable to release static external IP address: %w",err)}iferr=op.Wait(ctx);err!=nil{returnfmt.Errorf("unable to wait for the operation: %w",err)}fmt.Fprintf(w,"Static external IP address released\n")returnnil}

importcom.google.cloud.compute.v1.AddressesClient;importcom.google.cloud.compute.v1.DeleteAddressRequest;importcom.google.cloud.compute.v1.DeleteGlobalAddressRequest;importcom.google.cloud.compute.v1.GlobalAddressesClient;importcom.google.cloud.compute.v1.Operation;importjava.io.IOException;importjava.util.concurrent.ExecutionException;importjava.util.concurrent.TimeUnit;importjava.util.concurrent.TimeoutException;publicclassReleaseStaticAddress{publicstaticvoidmain(String[]args)throwsIOException,ExecutionException,InterruptedException,TimeoutException{// TODO(developer): Replace these variables before running the sample.// Project ID or project number of the Google Cloud project you want to use.StringprojectId="your-project-id";// The region to reserve the IP address in, if regional. Must be None if globalStringregion="your-region =";// Name of the address to release.StringaddressName="your-addressName";releaseStaticAddress(projectId,addressName,region);}// Releases a static external IP address that is currently reserved.// This action requires that the address is not being used by any forwarding rule.publicstaticvoidreleaseStaticAddress(StringprojectId,StringaddressName,Stringregion)throwsIOException,ExecutionException,InterruptedException,TimeoutException{Operationoperation;// Use global client if no region is specifiedif(region==null){// Initialize client that will be used to send requests. This client only needs to be created// once, and can be reused for multiple requests.try(GlobalAddressesClientclient=GlobalAddressesClient.create()){DeleteGlobalAddressRequestrequest=DeleteGlobalAddressRequest.newBuilder().setProject(projectId).setAddress(addressName).build();operation=client.deleteCallable().futureCall(request).get(30,TimeUnit.SECONDS);}}else{// Initialize client that will be used to send requests. This client only needs to be created// once, and can be reused for multiple requests.try(AddressesClientclient=AddressesClient.create()){DeleteAddressRequestrequest=DeleteAddressRequest.newBuilder().setProject(projectId).setRegion(region).setAddress(addressName).build();operation=client.deleteCallable().futureCall(request).get(30,TimeUnit.SECONDS);}}if(operation.hasError()){System.out.printf("Can't release external IP address '%s'. Caused by : %s",addressName,operation.getError());}System.out.printf("External IP address '%s' released successfully.",addressName);}}

fromtypingimportOptionalfromgoogle.cloud.compute_v1.services.addresses.clientimportAddressesClientfromgoogle.cloud.compute_v1.services.global_addressesimportGlobalAddressesClientdefrelease_external_ip_address(project_id:str,address_name:str,region:Optional[str]=None,)->None:"""    Releases a static external IP address that is currently reserved.    This action requires that the address is not being used by any forwarding rule.    Args:        project_id (str): project ID.        address_name (str): name of the address to release.        region (Optional[str]): The region to reserve the IP address in, if regional. Must be None if global.    """ifnotregion:# global IP addressclient=GlobalAddressesClient()operation=client.delete(project=project_id,address=address_name)else:# regional IP addressclient=AddressesClient()operation=client.delete(project=project_id,region=region,address=address_name)operation.result()print(f"External IP address '{address_name}' released successfully.")