List uptime-check server IP addresses

This document shows you how to get a list of IP addresses used by uptime-check servers, and how you can identify traffic from the uptime-check servers in your logs.

List IP addresses

When you're checking a service that is behind a firewall, you can configure your service's firewall to accept traffic from the current set of IP addresses used for uptime checking. To get these IP addresses, use the following instructions:

Console

  1. In the Google Cloud console, select Monitoring or click the following button:
    Go to Monitoring
  2. In the navigation pane, select Uptime checks.
  3. In the Uptime checks menu, click Download . A file uptime-source-ips.txt is downloaded and contains the IP addresses.

API

  1. Call the uptimeCheckIps.list method of the Monitoring API.

  2. The method returns the following information for each IP address:

    • The region: USA, EUROPE, SOUTH_AMERICA, or ASIA_PACIFIC.
    • A more specific location within the region.
    • The IP address, not a range, in IPv4 or IPv6 format.

C#

public static object ListUptimeCheckIps()
{
    var client = UptimeCheckServiceClient.Create();
    var ips = client.ListUptimeCheckIps(new ListUptimeCheckIpsRequest());
    foreach (UptimeCheckIp ip in ips)
    {
        Console.WriteLine("{0,20} {1}", ip.IpAddress, ip.Location);
    }
    return 0;
}

Java

private static void listUptimeCheckIps() throws IOException {
  try (UptimeCheckServiceClient client = UptimeCheckServiceClient.create()) {
    ListUptimeCheckIpsPagedResponse response =
        client.listUptimeCheckIps(ListUptimeCheckIpsRequest.newBuilder().build());
    for (UptimeCheckIp config : response.iterateAll()) {
      System.out.println(config.getRegion() + " - " + config.getIpAddress());
    }
  } catch (Exception e) {
    usage("Exception listing uptime IPs: " + e.toString());
    throw e;
  }
}

Go


// listIPs is an example of listing uptime check IPs.
func listIPs(w io.Writer) error {
	ctx := context.Background()
	client, err := monitoring.NewUptimeCheckClient(ctx)
	if err != nil {
		return fmt.Errorf("NewUptimeCheckClient: %v", err)
	}
	defer client.Close()
	req := &monitoringpb.ListUptimeCheckIpsRequest{}
	it := client.ListUptimeCheckIps(ctx, req)
	for {
		config, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("ListUptimeCheckIps: %v", err)
		}
		fmt.Fprintln(w, config)
	}
	fmt.Fprintln(w, "Done listing uptime check IPs")
	return nil
}

Node.js

// Imports the Google Cloud client library
const monitoring = require('@google-cloud/monitoring');

// Creates a client
const client = new monitoring.UptimeCheckServiceClient();

// List uptime check IPs
const [uptimeCheckIps] = await client.listUptimeCheckIps();
uptimeCheckIps.forEach(uptimeCheckIp => {
  console.log(
    uptimeCheckIp.region,
    uptimeCheckIp.location,
    uptimeCheckIp.ipAddress
  );
});

PHP

use Google\Cloud\Monitoring\V3\UptimeCheckServiceClient;

/**
 * Example:
 * ```
 * list_uptime_check_ips($projectId);
 * ```
 */
function list_uptime_check_ips($projectId)
{
    $uptimeCheckClient = new UptimeCheckServiceClient([
        'projectId' => $projectId,
    ]);

    $pages = $uptimeCheckClient->listUptimeCheckIps();

    foreach ($pages->iteratePages() as $page) {
        $ips = $page->getResponseObject()->getUptimeCheckIps();
        foreach ($ips as $ip) {
            printf(
                'ip address: %s, region: %s, location: %s' . PHP_EOL,
                $ip->getIpAddress(),
                $ip->getRegion(),
                $ip->getLocation()
            );
        }
    }
}

Python

def list_uptime_check_ips():
    client = monitoring_v3.UptimeCheckServiceClient()
    ips = client.list_uptime_check_ips(request={})
    print(
        tabulate.tabulate(
            [(ip.region, ip.location, ip.ip_address) for ip in ips],
            ("region", "location", "ip_address"),
        )
    )

Ruby

def list_ips
  require "google/cloud/monitoring"
  client = Google::Cloud::Monitoring.uptime_check_service

  # Iterate over all results.
  client.list_uptime_check_ips({}).each do |element|
    puts "#{element.location} #{element.ip_address}"
  end
end

Uptime checks can come from any of the IP addresses, but only one address from each geographic location is used for each time interval. The geographic locations are listed in the uptime checks dashboard, as shown in the previous section. You can also use free, web-based services to identify the registered locations of the IP addresses you downloaded.

Identify uptime-check traffic in logs

You can identify requests from the uptime-check servers by the following information in your service's request logs:

  • ip: The ip field contains one of the addresses used by the uptime-check servers. For information about how to list all IP addresses, see List IP addresses.
  • User-Agent: The User-Agent header value is always the following:

    GoogleStackdriverMonitoring-UptimeChecks(https://cloud.google.com/monitoring)
    

    Specifying a User-Agent custom header results in a form validation error and prevents the check configuration from being saved.

What's next