पब्लिशर से मिला आईपी पता सेट अप करना

ब्राउज़र की निजता प्रॉक्सी और आईपी पते की सुरक्षा से जुड़ी सेटिंग, Google Ad Manager को भेजे जाने वाले तीसरे पक्ष के विज्ञापन दिखाने के अनुरोधों पर क्लाइंट के आईपी पते छिपा सकती हैं. आईपी पते छिपाने से, इलाके के हिसाब से टारगेट करने की सुविधा की सटीक जानकारी और विज्ञापन की प्रासंगिकता कम हो सकती है. आपका वेब सर्वर या कॉन्टेंट डिलीवरी नेटवर्क (सीडीएन), उपयोगकर्ता के साथ पहले पक्ष के कॉन्टेक्स्ट में इंटरैक्ट करता है. इसलिए, आपके सर्वर को उपयोगकर्ता का अनमास्क किया गया आईपी पता मिलता है.

पब्लिशर से मिले आईपी पते की सुविधा की मदद से, अपने सर्वर पर उपयोगकर्ता का मास्क नहीं किया गया IPv4 या IPv6 पता कैप्चर किया जा सकता है. साथ ही, हाइब्रिड सार्वजनिक पासकोड एन्क्रिप्शन (HPKE) का इस्तेमाल करके, पते को एन्क्रिप्ट (सुरक्षित) किया जा सकता है. इसके बाद, एन्क्रिप्ट किए गए पेलोड को क्लाइंट पर Google पब्लिशर टैग (GPT) को भेजा जा सकता है.

इस पेज पर, पब्लिशर से मिले आईपी पते को GPT के साथ इंटिग्रेट करने के बारे में बताया गया है.

सर्वर साइड वर्कफ़्लो लागू करना

ब्राउज़र में तीसरे पक्ष की स्क्रिप्ट को उपयोगकर्ता का आईपी पता सादे टेक्स्ट के तौर पर न दिखे, इसके लिए अपने वेब सर्वर या सीडीएन एज वर्कर पर यह तरीका अपनाएं:

  • सभी आईपी कैप्चर करें.
  • सार्वजनिक पासकोड फ़ेच करें.
  • एचपीकेई एन्क्रिप्शन की सुविधा चालू करें.

क्लाइंट का आईपी पता कैप्चर करना

अपने वेब सर्वर या सीडीएन पर, पेज के लिए आने वाले अनुरोध से क्लाइंट का अनमास्क किया गया IPv4 या IPv6 पता निकालें:

  • डायरेक्ट कनेक्शन: आने वाले एचटीटीपी कनेक्शन के रिमोट सॉकेट पते को पढ़ें.
  • सीडीएन, लोड बैलेंसर या रिवर्स प्रॉक्सी के पीछे: अपने भरोसेमंद एज प्रॉक्सी से क्लाइंट आईपी हेडर पढ़ें. जैसे, X-Forwarded-For हेडर या सीडीएन के लिए क्लाइंट आईपी हेडर. सिर्फ़ उन फ़ॉरवर्डिंग हेडर पर भरोसा करें जिन्हें आपका प्रॉक्सी इन्फ़्रास्ट्रक्चर जोड़ता है या बदलता है. जब X-Forwarded-For हेडर में कॉमा लगाकर अलग किए गए कई पते शामिल हों, तो वह क्लाइंट आईपी चुनें जिसे भरोसेमंद एज प्रॉक्सी ने जोड़ा है.

Ad Manager में इन पतों का इस्तेमाल किया जा सकता है:

  • IPv4, जैसे कि 203.0.113.42.
  • IPv6, जैसे कि 2001:db8::8a2e:370:7334.

सिर्फ़ आईपी पते की स्ट्रिंग पास करें. इसमें पोर्ट नंबर, ब्रैकेट, सीआईडीआर प्रीफ़िक्स या आस-पास खाली जगह नहीं होनी चाहिए.

सार्वजनिक पासकोड फ़ेच और कैश मेमोरी में सेव करना

Google, एचपीकेई की मदद से एन्क्रिप्ट (सुरक्षित) करने की चालू कुंजी को आरएफ़सी 8037 JSON वेब की सेट (JWKS) के तौर पर, इस एंडपॉइंट पर पब्लिश करता है:

https://www.gstatic.com/real-ip/ip_enc_key.json

इस एंडपॉइंट पर GET अनुरोध करने पर, एक JSON ऑब्जेक्ट मिलता है. इसके keys कलेक्शन में, एक ऐक्टिव कुंजी ऑब्जेक्ट होता है. क्लाइंट के आईपी पते को एन्क्रिप्ट करने के लिए, उस ऑब्जेक्ट की x प्रॉपर्टी में मौजूद कुंजी का इस्तेमाल करें.

यहां दिए गए उदाहरण में, सार्वजनिक पासकोड को फ़ेच किया गया है. साथ ही, फ़ेच होने पर x प्रॉपर्टी को निकाला गया है और फ़ेच न होने पर गड़बड़ी का मैसेज दिखाया गया है:

Java

private static final String KEY_ENDPOINT_URL = "https://www.gstatic.com/real-ip/ip_enc_key.json";

/**
 * Fetches the active X25519 public key from Google's key endpoint.
 *
 * <p>In production, cache the returned public key in memory and refresh it at least once every 24
 * hours rather than fetching it on every incoming request.
 *
 * @return The unpadded Base64URL-encoded 32-byte X25519 public key ('x').
 */
public static String fetchPublicKey() throws IOException, InterruptedException {
  return fetchPublicKey(KEY_ENDPOINT_URL);
}

public static String fetchPublicKey(String endpointUrl) throws IOException, InterruptedException {
  HttpClient client = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(5)).build();
  HttpRequest request =
      HttpRequest.newBuilder()
          .uri(URI.create(endpointUrl))
          .timeout(Duration.ofSeconds(5))
          .GET()
          .build();
  HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
  if (response.statusCode() < 200 || response.statusCode() >= 300) {
    throw new IOException("Failed to fetch public key, HTTP status: " + response.statusCode());
  }
  JsonObject json = JsonParser.parseString(response.body()).getAsJsonObject();
  JsonArray keys = json.getAsJsonArray("keys");
  if (keys == null || keys.isEmpty()) {
    throw new IOException("No keys found in response from " + endpointUrl);
  }
  JsonObject keyObj = keys.get(0).getAsJsonObject();
  if (!keyObj.has("x")) {
    throw new IOException("Key payload missing 'x' property: " + keyObj);
  }
  return keyObj.get("x").getAsString();
}

Python

KEY_ENDPOINT_URL = "https://www.gstatic.com/real-ip/ip_enc_key.json"


def fetch_public_key(url: str = KEY_ENDPOINT_URL) -> str:
  """Fetches the active X25519 public key from Google's key endpoint.

  In production, cache the returned public key in memory and refresh it at
  least once every 24 hours rather than fetching it on every incoming request.

  Args:
    url: URL of the public key endpoint.

  Returns:
    The unpadded Base64URL-encoded 32-byte X25519 public key ('x').
  """
  with urllib.request.urlopen(url, timeout=5) as response:
    data = json.loads(response.read().decode("utf-8"))
  keys = data.get("keys", [])
  if not keys:
    raise ValueError(f"No keys found in response from {url}")
  key_payload = keys[0].get("x")
  if not key_payload:
    raise ValueError(f"Key payload missing 'x' property: {keys[0]}")
  return key_payload

JavaScript

const KEY_ENDPOINT_URL = 'https://www.gstatic.com/real-ip/ip_enc_key.json';

/**
 * Fetches the active X25519 public key from Google's key endpoint.
 *
 * In production, cache the returned public key in memory and refresh it at
 * least once every 24 hours rather than fetching it on every incoming request.
 *
 * @param {string=} url URL of the public key endpoint.
 * @return {!Promise<string>} The unpadded Base64URL-encoded 32-byte X25519
 *     public key ('x').
 */
async function fetchPublicKey(url = KEY_ENDPOINT_URL) {
  const response = await fetch(url);
  if (!response.ok) {
    throw new Error(
      `Failed to fetch public key, HTTP status: ${response.status}`,
    );
  }
  const data = await response.json();
  if (!data.keys || data.keys.length === 0) {
    throw new Error(`No keys found in response from ${url}`);
  }
  const keyPayload = data.keys[0].x;
  if (!keyPayload) {
    throw new Error(
      `Key payload missing 'x' property: ${JSON.stringify(data.keys[0])}`,
    );
  }
  return keyPayload;
}

TypeScript

const KEY_ENDPOINT_URL = 'https://www.gstatic.com/real-ip/ip_enc_key.json';

interface JwkKey {
  kty?: string;
  crv?: string;
  x?: string;
  kid?: string;
}

interface KeyEndpointResponse {
  keys?: JwkKey[];
}

/**
 * Fetches the active X25519 public key from Google's key endpoint.
 *
 * In production, cache the returned public key in memory and refresh it at
 * least once every 24 hours rather than fetching it on every incoming request.
 *
 * @param url URL of the public key endpoint.
 * @return The unpadded Base64URL-encoded 32-byte X25519 public key ('x').
 */
export async function fetchPublicKey(
  url: string = KEY_ENDPOINT_URL,
): Promise<string> {
  const response = await fetch(url);
  if (!response.ok) {
    throw new Error(
      `Failed to fetch public key, HTTP status: ${response.status}`,
    );
  }
  const data = (await response.json()) as KeyEndpointResponse;
  if (!data.keys || data.keys.length === 0) {
    throw new Error(`No keys found in response from ${url}`);
  }
  const keyPayload = data.keys[0].x;
  if (!keyPayload) {
    throw new Error(
      `Key payload missing 'x' property: ${JSON.stringify(data.keys[0])}`,
    );
  }
  return keyPayload;
}

अगर अनुरोध सही से काम करता है, तो जवाब में keys कलेक्शन शामिल होता है. इसमें x प्रॉपर्टी वाला एक मुख्य ऑब्जेक्ट होता है:

{
  "keys": [
    {
      "kty": "OKP",
      "crv": "X25519",
      "x": "7bws5TIHOUrcJNofEubW3DPW8zR9EtjFNLm_Grv98TA",
      "kid": "EZMLFw"
    }
  ]
}

नीचे दी गई टेबल में, keys कलेक्शन में मौजूद मुख्य ऑब्जेक्ट की प्रॉपर्टी के बारे में बताया गया है:

प्रॉपर्टी ब्यौरा
crv एलिप्टिक कर्व आइडेंटिफ़ायर. हमेशा X25519.
kid अनपैडेड base64url-कोड में बदला गया कुंजी आइडेंटिफ़ायर, जो Google के कुंजी को घुमाने पर बदल जाता है.
kty कुंजी का टाइप. हमेशा OKP (ऑक्टेट कुंजी का जोड़ा).
x एन्क्रिप्ट करने के लिए इस्तेमाल की जाने वाली, अनपैडेड base64url-एन्कोडेड 32-बाइट रॉ X25519 सार्वजनिक कुंजी.

फ़ेच की गई सार्वजनिक कुंजी को अपने सर्वर की मेमोरी में कैश मेमोरी में सेव करें. साथ ही, हर 24 घंटे में कम से कम एक बार या एचटीटीपी Cache-Control रिस्पॉन्स हेडर के मुताबिक, कुंजी को रीफ़्रेश करें. पेज के लिए आने वाले हर अनुरोध पर, सार्वजनिक पासकोड फ़ेच न करें. Google, रोटेट की गई निजी कुंजियों को सेव रखता है. पिछले 24 घंटों में कैश मेमोरी में सेव किए गए सार्वजनिक पासकोड से एन्क्रिप्ट किए गए पेलोड, पासकोड रोटेशन के दौरान बिना किसी रुकावट के डिक्रिप्ट होते रहते हैं.

आईपी पते को एन्क्रिप्ट (सुरक्षित) करना

एचपीकेई (आरएफ़सी 9180) और डिकोड की गई 32-बाइट वाली X25519 सार्वजनिक कुंजी, x का इस्तेमाल करके, क्लाइंट के आईपी पते की स्ट्रिंग के UTF-8 बाइट वर्शन को एन्क्रिप्ट करें. यह कुंजी, सार्वजनिक कुंजी को फ़ेच और कैश मेमोरी में सेव करें में वापस पाई गई है.

यहां दिए गए उदाहरण में, आईपी पते की स्ट्रिंग को एन्क्रिप्ट (सुरक्षित) किया गया है:

Java

इस उदाहरण में Tink (com.google.crypto.tink:tink 1.16.0 या इसके बाद के वर्शन) का इस्तेमाल किया गया है:

static {
  try {
    HybridConfig.register();
  } catch (GeneralSecurityException e) {
    throw new ExceptionInInitializerError(e);
  }
}

/**
 * Encrypts an IP address using HPKE (DHKEM(X25519, HKDF-SHA256), HKDF-SHA256, AES-256-GCM).
 *
 * @param pubXB64Url Base64URL-encoded 32-byte X25519 public key ('x').
 * @param ipStr Plaintext IPv4 or IPv6 address string (for example, "203.0.113.42").
 * @return Unpadded Base64URL-encoded payload (enc || ciphertext).
 */
@AccessesPartialKey
public static String encryptIp(String pubXB64Url, String ipStr) throws GeneralSecurityException {
  // 1. Decode the 32-byte X25519 public key 'x' from Base64URL.
  byte[] pubBytes = Base64.getUrlDecoder().decode(pubXB64Url);
  if (pubBytes.length != 32) {
    throw new IllegalArgumentException(
        "Public key must be exactly 32 bytes, got " + pubBytes.length);
  }

  // 2. Configure HPKE parameters (DHKEM_X25519_HKDF_SHA256, HKDF_SHA256,
  //    AES_256_GCM, NO_PREFIX).
  HpkeParameters parameters =
      HpkeParameters.builder()
          .setKemId(HpkeParameters.KemId.DHKEM_X25519_HKDF_SHA256)
          .setKdfId(HpkeParameters.KdfId.HKDF_SHA256)
          .setAeadId(HpkeParameters.AeadId.AES_256_GCM)
          .setVariant(HpkeParameters.Variant.NO_PREFIX)
          .build();

  HpkePublicKey publicKey =
      HpkePublicKey.create(parameters, Bytes.copyFrom(pubBytes), /* idRequirement= */ null);

  // 3. Encrypt the UTF-8 IP address bytes. With Variant.NO_PREFIX, Tink
  //    outputs raw (enc || ciphertext_with_tag).
  KeysetHandle handle =
      KeysetHandle.newBuilder()
          .addEntry(KeysetHandle.importKey(publicKey).withRandomId().makePrimary())
          .build();

  HybridEncrypt encryptor = handle.getPrimitive(RegistryConfiguration.get(), HybridEncrypt.class);
  byte[] payload =
      encryptor.encrypt(ipStr.getBytes(StandardCharsets.UTF_8), /* contextInfo= */ new byte[0]);

  // 4. Return unpadded Base64URL-encoded payload.
  return Base64.getUrlEncoder().withoutPadding().encodeToString(payload);
}

Python

इस उदाहरण में pyhpke का इस्तेमाल किया गया है:

def encrypt_ip(pub_x_b64url: str, ip_str: str) -> str:
  """Encrypts an IP address using HPKE (RFC 9180).

  Args:
    pub_x_b64url: Base64URL-encoded 32-byte X25519 public key ('x').
    ip_str: Plaintext IPv4 or IPv6 address string (for example, "203.0.113.42").

  Returns:
    Unpadded Base64URL-encoded payload (enc || ciphertext).
  """
  # 1. Decode the 32-byte X25519 public key 'x' from Base64URL.
  pub_bytes = base64.urlsafe_b64decode(
      pub_x_b64url + "=" * (-len(pub_x_b64url) % 4)
  )
  if len(pub_bytes) != 32:
    raise ValueError(
        f"Public key must be exactly 32 bytes, got {len(pub_bytes)}"
    )

  # 2. Configure HPKE cipher suite (DHKEM_X25519_HKDF_SHA256, HKDF_SHA256,
  #    AES256_GCM).
  suite = CipherSuite.new(
      KEMId.DHKEM_X25519_HKDF_SHA256, KDFId.HKDF_SHA256, AEADId.AES256_GCM
  )
  public_key = suite.kem.deserialize_public_key(pub_bytes)

  # 3. Create a fresh sender context per encryption (you may cache 'suite' and
  #    'public_key', but never reuse 'sender' across multiple seal() calls) and
  #    package (enc || ciphertext).
  enc, sender = suite.create_sender_context(public_key)
  ciphertext = sender.seal(ip_str.encode("utf-8"))

  # 4. Return unpadded Base64URL-encoded payload.
  return base64.urlsafe_b64encode(enc + ciphertext).decode("utf-8").rstrip("=")

JavaScript

इस उदाहरण में @hpke/core का इस्तेमाल किया गया है:

/**
 * Encrypts an IP address using HPKE (RFC 9180).
 *
 * @param {string} pubXB64Url Base64URL-encoded 32-byte X25519 public key ('x').
 * @param {string} ipStr Plaintext IPv4 or IPv6 address string (for example,
 *     "203.0.113.42").
 * @return {!Promise<string>} Unpadded Base64URL-encoded payload
 *     (enc || ciphertext).
 */
async function encryptIp(pubXB64Url, ipStr) {
  // 1. Decode the 32-byte X25519 public key 'x' from Base64URL.
  const pubBytes = Buffer.from(pubXB64Url, 'base64url');
  if (pubBytes.length !== 32) {
    throw new Error(
      `Public key must be exactly 32 bytes, got ${pubBytes.length}`,
    );
  }

  // 2. Configure HPKE cipher suite (DHKEM_X25519_HKDF_SHA256, HKDF_SHA256,
  //    AES_256_GCM).
  const suite = new CipherSuite({
    kem: new DhkemX25519HkdfSha256(),
    kdf: new HkdfSha256(),
    aead: new Aes256Gcm(),
  });
  const rawPubKey = new Uint8Array(pubBytes).buffer;
  const publicKey = await suite.kem.importKey('raw', rawPubKey, true);

  // 3. Encrypt the UTF-8 IP address bytes and package (enc || ciphertext).
  const plaintext = new Uint8Array(Buffer.from(ipStr, 'utf8')).buffer;
  const {enc, ct} = await suite.seal(
    {recipientPublicKey: publicKey},
    plaintext,
  );

  // 4. Return unpadded Base64URL-encoded payload.
  return Buffer.concat([Buffer.from(enc), Buffer.from(ct)]).toString(
    'base64url',
  );
}

TypeScript

इस उदाहरण में @hpke/core का इस्तेमाल किया गया है:

/**
 * Encrypts an IP address using HPKE (RFC 9180).
 *
 * @param pubXB64Url Base64URL-encoded 32-byte X25519 public key ('x').
 * @param ipStr Plaintext IPv4 or IPv6 address string (for example,
 *     "203.0.113.42").
 * @return Unpadded Base64URL-encoded payload (enc || ciphertext).
 */
export async function encryptIp(
  pubXB64Url: string,
  ipStr: string,
): Promise<string> {
  // 1. Decode the 32-byte X25519 public key 'x' from Base64URL.
  const pubBytes = Buffer.from(pubXB64Url, 'base64url');
  if (pubBytes.length !== 32) {
    throw new Error(
      `Public key must be exactly 32 bytes, got ${pubBytes.length}`,
    );
  }

  // 2. Configure HPKE cipher suite (DHKEM_X25519_HKDF_SHA256, HKDF_SHA256,
  //    AES_256_GCM).
  const suite = new CipherSuite({
    kem: new DhkemX25519HkdfSha256(),
    kdf: new HkdfSha256(),
    aead: new Aes256Gcm(),
  });
  const rawPubKey = new Uint8Array(pubBytes).buffer;
  const publicKey = await suite.kem.importKey('raw', rawPubKey, true);

  // 3. Encrypt the UTF-8 IP address bytes and package (enc || ciphertext).
  const plaintext = new Uint8Array(Buffer.from(ipStr, 'utf8')).buffer;
  const {enc, ct} = await suite.seal(
    {recipientPublicKey: publicKey},
    plaintext,
  );

  // 4. Return unpadded Base64URL-encoded payload.
  return Buffer.concat([Buffer.from(enc), Buffer.from(ct)]).toString(
    'base64url',
  );
}

अपनी एचपीकेई लाइब्रेरी को इन साइफ़र सुइट और पैरामीटर के साथ कॉन्फ़िगर करें:

पैरामीटर वैल्यू
की एनकैप्सुलेशन मैकेनिज़्म (केईएम) DHKEM(X25519, HKDF-SHA256) (0x0020)
की डेरिवेशन फ़ंक्शन (केडीएफ़) HKDF-SHA256 (0x0001)
Authenticated Encryption with Associated Data (AEAD) AES-256-GCM (0x0002)
मोड बेस (0x00)
ऐप्लिकेशन की जानकारी (info) खाली है ("")
इससे जुड़ा डेटा (aad) खाली है ("")

एन्क्रिप्ट किए गए आउटपुट को 32-बाइट के एन्कैप्सुलेट किए गए अस्थायी सार्वजनिक पासकोड, enc, और एईएडी साइफ़रटेक्स्ट के रॉ कॉनकैटेनेशन के तौर पर फ़ॉर्मैट करें. इसमें 16-बाइट का जीसीएम ऑथेंटिकेशन टैग शामिल होना चाहिए. इसमें Tink या कस्टम हेडर प्रीफ़िक्स नहीं होना चाहिए. नतीजे को अनपैडेड base64url स्ट्रिंग के तौर पर कोड में बदलें.

हर पेलोड को एक स्टैंडअलोन सिंगल-शॉट एचपीकेई मैसेज के तौर पर एन्क्रिप्ट (सुरक्षित) करें. इसके लिए, कुछ समय के लिए इस्तेमाल होने वाली नई कुंजी के जोड़े का इस्तेमाल करें. अगर आपकी एचपीकेई लाइब्रेरी, स्टेटफ़ुल सेंडर कॉन्टेक्स्ट का इस्तेमाल करती है, तो हर एन्क्रिप्शन के लिए एक नया कॉन्टेक्स्ट बनाएं. इसे कई मैसेज में फिर से इस्तेमाल न करें. हर पेज के अनुरोध के हिसाब से क्लाइंट के आईपी पते को एन्क्रिप्ट करें या हर आईपी पते के हिसाब से, base64url साइफ़रटेक्स्ट स्ट्रिंग को कम समय के लिए कैश मेमोरी में सेव करें.

क्लाइंट-साइड वर्कफ़्लो लागू करना

जब आपका सर्वर, एन्क्रिप्ट (सुरक्षित) किया गया base64url आईपी पेलोड जनरेट कर लेता है, तो विज्ञापनों का अनुरोध करने से पहले, क्लाइंट पर पेलोड को GPT को पास करें.

एन्क्रिप्ट किए गए आईपी को GPT को पास करना

PageSettingsConfig पर ipAddress प्रॉपर्टी का इस्तेमाल करके, एन्क्रिप्ट की गई आईपी स्ट्रिंग को googletag.setConfig तरीके से पास करें.

यहां दिए गए उदाहरण में, सर्वर से जनरेट किए गए एन्क्रिप्ट किए गए आईपी पेलोड को googletag.setConfig तरीके में डाला गया है. ऐसा सेवाएं चालू करने और विज्ञापन स्लॉट दिखाने से पहले किया गया है:

<!doctype html>
<html>
  <head>
    <meta charset="utf-8">
    <title>Publisher-provided IP example</title>
    <script src="https://securepubads.g.doubleclick.net/tag/js/gpt.js" crossorigin="anonymous" async></script>
    <script>
      window.googletag = window.googletag || {cmd: []};

      // Inject the base64url-encoded encrypted IP generated by your server.
      const encryptedClientIp = 'ENCRYPTED_IP_PAYLOAD';

      googletag.cmd.push(function() {
        // Configure the encrypted IP before enabling services.
        googletag.setConfig({
          ipAddress: encryptedClientIp,
        });

        googletag
            .defineSlot('/6355419/Travel/Europe/France/Paris', [300, 250], 'banner-ad')
            .addService(googletag.pubads());
        googletag.enableServices();
      });
    </script>
  </head>
  <body>
    <div id="banner-ad" style="width: 300px; height: 250px;"></div>
    <script>
      googletag.cmd.push(function() {
        googletag.display('banner-ad');
      });
    </script>
  </body>
</html>

ENCRYPTED_IP_PAYLOAD को, आपके सर्वर से जनरेट की गई base64url-encoded स्ट्रिंग से बदलें. इस स्ट्रिंग में पैडिंग नहीं होनी चाहिए.

पेज पर पहले से कॉन्फ़िगर किए गए आईपी पते को हटाने के लिए, ipAddress प्रॉपर्टी को null वैल्यू पर सेट करें:

googletag.setConfig({ ipAddress: null });

इंटिग्रेशन की पुष्टि करना

यह पुष्टि करने के लिए कि GPT आपके एन्क्रिप्ट किए गए आईपी पेलोड को भेजता है और Ad Manager पेलोड को डिक्रिप्ट करता है, अपने ब्राउज़र के डेवलपर टूल और Google पब्लिशर कंसोल का इस्तेमाल करें:

ब्राउज़र डेवलपर टूल

  1. अपने ब्राउज़र के डेवलपर टूल खोलें.
  2. नेटवर्क टैब चुनें.
  3. /gampad/ads पर विज्ञापन दिखाने के अनुरोधों को ढूंढने के लिए फ़िल्टर का इस्तेमाल करें.
  4. पुष्टि करें कि अनुरोध के यूआरएल में, ips क्वेरी पैरामीटर की वैल्यू मौजूद हो. विज्ञापन दिखाने का अनुरोध भेजने से पहले, GPT ipAddress वैल्यू को एन्क्रिप्ट (सुरक्षित) करता है. इसलिए, ips पैरामीटर आपकी एन्क्रिप्ट की गई स्ट्रिंग से पूरी तरह मैच नहीं करता.

Google प्रकाशक कंसोल

  1. कंसोल खोलने के लिए, Google पब्लिशर कंसोल गाइड में दिया गया तरीका अपनाएं.
  2. पेज के लिए अनुरोध टैब को चुनें.

  3. पुष्टि करें कि ipAddress से जुड़ी कोई चेतावनी न दिखे. पेलोड में कोई समस्या होने पर, कंसोल इनमें से कोई एक चेतावनी लॉग करता है:

    • अगर ipAddress प्रॉपर्टी को पास की गई वैल्यू, 67 से 124 वर्णों के बीच की मान्य base64 या base64url स्ट्रिंग नहीं है, तो GPT उस वैल्यू को अनदेखा कर देता है. साथ ही, विज्ञापन दिखाने के अनुरोध से ips पैरामीटर को हटा देता है और यह चेतावनी लॉग करता है:

      Invalid value encountered when calling: googletag.setConfig: {"ipAddress":"..."}. (string) ... was found at PageSettingsConfig.ipAddress. Invalid IP address format.

    • अगर Ad Manager, दिए गए आईपी पेलोड को डिक्रिप्ट नहीं कर पाता है या डिक्रिप्ट किया गया सादा टेक्स्ट, मान्य IPv4 या IPv6 पता नहीं है, तो कंसोल यह चेतावनी लॉग करता है और नेटवर्क अनुरोध के आईपी पते पर वापस चला जाता है:

      Decryption failed on the provided encrypted client IP (supplied via googletag.setConfig({ipAddress: ...})).