Fragmentar arquivos de feed (legado)

Dependendo do seu inventário, pode ser necessário dividir os feeds em vários arquivos.

Observação:o sharding pode ser aplicável apenas a alguns dos feeds que você envia e depende do tipo de inventário enviado. Entre em contato com seu contato do Google se não tiver certeza da melhor abordagem.

Quando usar o sharding

• O feed excede 200 MB para um arquivo (após a compactação gzip).

  • Exemplo:o feed de disponibilidade gerado é de 1 GB. Ele precisa ser fragmentado em mais de cinco arquivos separados (ou fragmentos).

• O inventário do parceiro é distribuído entre sistemas e/ou regiões, resultando em dificuldade para reconciliar o inventário.

  • Exemplo:o parceiro tem inventário dos EUA e da UE em sistemas separados. O feed pode ser gerado com dois arquivos (ou fragmentos), um para os EUA e outro para a UE, com o mesmo nonce e generation_timestamp.

Observação:antes de usar o sharding, verifique se você está comprimindo seus uploads de feed com gzip. O uso do gzip pode reduzir o tamanho do feed em 10 vezes ou mais e permitir que você pule ou adie o sharding do feed.

Regras gerais

• Cada fragmento não pode exceder 200 MB para um arquivo (após a compactação gzip).
• Recomendamos não usar mais de 20 fragmentos por feed. Se você tiver uma justificativa comercial que exija mais do que esse valor, entre em contato com o suporte para receber mais instruções.
• Registros individuais (um objeto Merchant, por exemplo) precisam ser enviados em um fragmento. Eles não podem ser divididos em vários fragmentos. No entanto, eles não precisam ser enviados no fragmento com o mesmo shard_number para feeds futuros.
• Para um melhor desempenho, seus dados devem ser divididos igualmente entre os fragmentos. Assim, todos os arquivos terão um tamanho parecido.

Observação:o Google processa arquivos de feed assim que eles são enviados para o servidor SFTP. Se o feed estiver fragmentado em vários arquivos, o processo vai começar após o upload do último. Caso seu feed contenha erros, você vai receber um e-mail com os códigos de erro do feed.

Como fragmentar feeds

Para cada arquivo (ou fragmento), defina o FeedMetadata como o seguinte:

• processing_instruction definido como PROCESS_AS_COMPLETE.
• shard_number definido como o fragmento atual do feed (iniciando de 0 a total_shards - 1 sem descontinuidades)
• total_shards definido como o número total de fragmentos do feed (a partir de 1).
• nonce definido como um identificador exclusivo igual em todos os fragmentos do mesmo feed, mas diferente do valor de outros feeds.
• generation_timestamp é o carimbo de data/hora no formato Unix e EPOCH. Ele precisa ser o mesmo em todos os fragmentos do feed.

Recomendado:para cada arquivo (ou fragmento), defina o nome do arquivo para indicar o tipo de feed, o carimbo de data/hora, o número do fragmento e o número total de fragmentos. Os fragmentos precisam ter tamanhos aproximadamente iguais e são processados quando todos os fragmentos são enviados.

• Example: “availability_feed_1574117613_001_of_002.json.gz”

Exemplo de feed de disponibilidade fragmentado

Fragmento 0

{
  "metadata": {
    "processing_instruction": "PROCESS_AS_COMPLETE",
    "shard_number": 0,
    "total_shards": 3,
    "nonce": "111111",
    "generation_timestamp": 1524606581
  },
  "service_availability": [
    {
      "availability": [
        {
          "spots_total": 1,
          "spots_open": 1,
          "duration_sec": 3600,
          "service_id": "1000",
          "start_sec": 1577275200,
          "merchant_id": "merchant1",
          "confirmation_mode": "CONFIRMATION_MODE_SYNCHRONOUS"
        }
      ]
    }
  ]
}

Fragmento 1

{
  "metadata": {
    "processing_instruction": "PROCESS_AS_COMPLETE",
    "shard_number": 1,
    "total_shards": 3,
    "nonce": "111111",
    "generation_timestamp": 1524606581
  },
  "service_availability": [
    {
      "availability": [
        {
          "spots_total": 1,
          "spots_open": 1,
          "duration_sec": 3600,
          "service_id": "1000",
          "start_sec": 1577620800,
          "merchant_id": "merchant2",
          "confirmation_mode": "CONFIRMATION_MODE_SYNCHRONOUS"
        }
      ]
    }
  ]
}

Fragmento 2

{
  "metadata": {
    "processing_instruction": "PROCESS_AS_COMPLETE",
    "shard_number": 2,
    "total_shards": 3,
    "nonce": "111111",
    "generation_timestamp": 1524606581
  },
  "service_availability": [
    {
      "availability": [
        {
          "spots_total": 1,
          "spots_open": 1,
          "duration_sec": 3600,
          "service_id": "1000",
          "start_sec": 1576670400,
          "merchant_id": "merchant3",
          "confirmation_mode": "CONFIRMATION_MODE_SYNCHRONOUS"
        }
      ]
    }
  ]
}

Como usar a fragmentação para inventário distribuído por parceiros

Pode ser difícil para os parceiros consolidar o inventário distribuído em vários sistemas e/ou regiões em um único feed. O fragmentação pode ser usado para resolver problemas de reconciliação definindo cada fragmento para corresponder a cada conjunto de inventário do sistema distribuído.

Por exemplo, digamos que o inventário de um parceiro seja dividido em duas regiões (inventário dos EUA e da UE), que estão em dois sistemas separados.

O parceiro pode dividir cada feed em dois arquivos (ou fragmentos):

• Feed de comerciantes: 1 fragmento para os EUA e 1 para a UE
• Feed de serviços: 1 fragmento para os EUA e 1 para a UE
• Feed de disponibilidade: 1 fragmento para os EUA e 1 para a UE

Siga as etapas abaixo para garantir que os feeds sejam processados corretamente:

1. Defina uma programação de upload e configure cada instância de inventário para seguir essa programação.
2. Atribua números de fragmento exclusivos para cada instância (por exemplo, EUA = N, UE = N + 1). Defina total_shards como o número total de fragmentos.
3. Em cada horário de envio programado, escolha um generation_timestamp e um nonce. No FeedMetadata, defina todas as instâncias para manter os mesmos valores para esses dois campos.
   • O generation_timestamp precisa ser atual ou recente (de preferência, o carimbo de data/hora de leitura do parceiro no banco de dados)
4. Depois que todos os fragmentos são enviados, o Google os agrupa usando generation_timestamp e nonce.

Observação:feeds/fragmentos que chegam separadamente em horários diferentes são aceitos, mas os horários coordenados são melhores. O processamento do feed só ocorre quando todos os fragmentos em um conjunto de feed são enviados.

O Google processa o feed como um único feed, mesmo que cada fragmento represente uma região diferente do inventário do parceiro e possa ser enviado em um horário diferente do dia, desde que o generation_timestamp seja o mesmo em todos os fragmentos.

Exemplo de feed de disponibilidade fragmentado por região

Fragmento 0: inventário dos EUA

{
  "metadata": {
    "processing_instruction": "PROCESS_AS_COMPLETE",
    "shard_number": 0,
    "total_shards": 2,
    "nonce": "111111",
    "generation_timestamp": 1524606581
  },
  "service_availability": [
    {
      "availability": [
        {
          "spots_total": 1,
          "spots_open": 1,
          "duration_sec": 3600,
          "service_id": "1000",
          "start_sec": 1577275200,
          "merchant_id": "US_merchant_1",
          "confirmation_mode": "CONFIRMATION_MODE_SYNCHRONOUS"
        }
      ]
    }
  ]
}

Fragmento 1: inventário da UE

{
  "metadata": {
    "processing_instruction": "PROCESS_AS_COMPLETE",
    "shard_number": 1,
    "total_shards": 2,
    "nonce": "111111",
    "generation_timestamp": 1524606581
  },
  "service_availability": [
    {
      "availability": [
        {
          "spots_total": 1,
          "spots_open": 1,
          "duration_sec": 3600,
          "service_id": "1000",
          "start_sec": 1577620800,
          "merchant_id": "EU_merchant_1",
          "confirmation_mode": "CONFIRMATION_MODE_SYNCHRONOUS"
        }
      ]
    }
  ]
}