Fragmentar arquivos de feed (legado)

Dependendo do seu inventário, pode ser necessário fazer o sharding (ou 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 tem 1 GB. Isso precisa ser dividido em 5 ou mais arquivos (ou fragmentos) separados.

• O inventário do parceiro é distribuído em sistemas e/ou regiões, o que dificulta a conciliação.

  • Exemplo:o parceiro tem inventário nos EUA e na UE que fica 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á compactando os uploads de feed com gzip. Usar gzip pode reduzir o tamanho do feed em 10 vezes ou mais e permitir que você pule ou adie o fragmento do feed.

Regras gerais

• Cada fragmento não pode exceder 200 MB para um arquivo (após a compactação gzip).
• Recomendamos no máximo 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.
• Os registros individuais (por exemplo, um objeto Merchant) precisam ser enviados em um fragmento e 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 começará após o upload do último. Se o feed tiver erros, você vai receber um e-mail com os códigos de erro do feed.

Como fragmentar feeds

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

• processing_instruction definido como PROCESS_AS_COMPLETE.
• shard_number definido como o fragmento atual do feed (começando de 0 a total_shards - 1 sem descontinuidades)
• total_shards definido como o número total de fragmentos para o feed (começando em 1).
• nonce definido como um identificador exclusivo que é o mesmo 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 depois que todos 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 de 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 sharding pode ser usado para resolver desafios de conciliação definindo cada shard para corresponder ao conjunto de inventário de cada sistema distribuído.

Por exemplo, digamos que o inventário de um parceiro seja separado em duas regiões (inventário dos EUA e da UE) que ficam 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. Decida uma programação de upload e configure cada instância de inventário para seguir a programação.
2. Atribua números de fragmentos exclusivos a 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 upload programado, decida um generation_timestamp e um nonce. No FeedMetadata, defina todas as instâncias para manter os mesmos valores nesses dois campos.
   • generation_timestamp precisa ser atual ou do passado recente (idealmente, o carimbo de data/hora do banco de dados de leitura do parceiro).
4. Depois que todos os fragmentos são enviados, o Google os agrupa usando generation_timestamp e nonce.

Observação:é possível usar feeds/fragmentos que chegam separadamente em horários diferentes, mas o ideal é ter programações coordenadas. O processamento do feed só ocorre quando todos os fragmentos de um conjunto de feeds são enviados.

O Google vai processar o feed como um só, 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 fragmentada 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"
        }
      ]
    }
  ]
}