Tutorial NerdGraph: Gerencie seu monitor Sintético

Nossa API NerdGraph permite automatizar a criação, atualização ou exclusão de seus monitores Sintético, localização privada, credenciais seguras e monitor período de inatividade.

Requisitos

Os requisitos incluem:

Requisitos gerais do NerdGraph
Permissões de usuário relevantes: as mesmas permissões de monitoramento sintético que se aplicam ao uso da interface Sintético se aplicam ao uso do NerdGraph

Entenda os campos no NerdGraph Explorer

Você pode visualizar as definições de campo no NerdGraph Explorer, mas isso pode ajudar a entender melhor os LOCATION, PERIOD, TAGS e outros campos.

Para identificar uma localização privada em seu script, use o GUID da entidade localização privada. Para verificar se um script foi executado com êxito, inclua também o atributo vsePassword . Por exemplo:

locations: {
  private: {
    guid: LOCATION_ENTITY_GUID, 
    vsePassword: YOUR_VSE_PASSWORD
  }
}

localização pública use o identificador de localização sem o prefixo AWS , por exemplo:

locations: {
  public: ["US_EAST_2", "US_WEST_1"]
}

O atributo PERIOD define um intervalo de tempo para a execução do seu monitor. Para definir o intervalo, use estes formulários:

EVERY_MINUTE para cada minuto.
EVERY_N_MINUTES, onde 'N' são minutos. Os valores suportados incluem EVERY_5_MINUTES, EVERY_10_MINUTES, EVERY_15_MINUTES e EVERY_30_MINUTES.
EVERY_HOUR para cada hora.
EVERY_N_HOURS, onde 'N' são horas. Os valores suportados incluem EVERY_6_HOURS e EVERY_12_HOURS.
EVERY_DAY uma vez por dia.

Alguns campos são para configurações mais avançadas. Estes são opcionais.

Para monitor de ping, incluem:

HEADER_NAME: seus nomes de cabeçalho personalizados que aparecem na solicitação.
HEADER_VALUE: o valor do cabeçalho personalizado na solicitação.
REDIRECT_IS_FAILURE: seu monitor relata uma falha se for redirecionado.
VALIDATION_TEXT: Se este texto não estiver incluído na resposta do seu monitor, ele retornará uma falha.
TLS_VALIDATION: Verifica a validade da cadeia de certificados SSL.
Para monitor de browser simples:
RUNTIME_TYPE: O tipo de tempo de execução usado pelo seu monitor. "CHROME_BROWSER" é o único valor aceito.
RUNTIME_TYPE_VERSION: A versão do tipo de tempo de execução usada pelo seu monitor. "100" é o único valor aceito.
SCRIPT_LANGUAGE: O idioma usado em seu monitor. "JAVASCRIPT" é o único valor aceito.
Para monitor de API com script:
SCRIPT_CONTENT: O conteúdo real do script. Isso não deve ser codificado em base64.
RUNTIME_TYPE: O tipo de tempo de execução usado pelo seu monitor. "NODE_API" é o único valor aceito.
RUNTIME_TYPE_VERSION: A versão do tipo de tempo de execução usada pelo seu monitor. O único valor aceito é 16.10.
SCRIPT_LANGUAGE: O idioma usado em seu monitor. "JAVASCRIPT" é o único valor aceito.
Para monitorar o script com do browser:
SCRIPT_CONTENT: O conteúdo real do script. Isso não deve ser codificado em base64.
RUNTIME_TYPE: O tipo de tempo de execução usado pelo seu monitor. "CHROME_BROWSER" é o único valor aceito.
RUNTIME_TYPE_VERSION: A versão do tipo de tempo de execução usada pelo seu monitor. "100" é o único valor aceito.
SCRIPT_LANGUAGE: O idioma usado em seu monitor. "JAVASCRIPT" é o único valor aceito.
Para monitor de verificação de certificado:
DAYS_UNTIL_EXPIRATION: Notifica quando você precisa atualizar seu certificado. Por exemplo, se você desejasse uma notificação 30 dias antes da expiração do certificado, você inseriria 30.
Para todos os monitores:
APDEX_TARGET: o destino Apdex do monitor usado para preencher relatórios de SLA. O padrão é 7 segundos (7.000 ms).

Use consulta para recuperar dados

Consulta faz solicitações para buscar dados. Para conhecer os recursos de consulta adicionais disponíveis para sua entidade Sintética, confira o tutorial da API NerdGraph entidade.

Você pode consultar seus monitores Sintético para obter informações de status atuais sobre seus dados ou detalhes sobre a configuração monitor . Alguns exemplos de consulta incluem:

{
  actor {
    entitySearch(query: "domain = 'SYNTH' AND type = 'MONITOR'") {
      results {
        entities {
          ... on SyntheticMonitorEntityOutline {
            guid
            name
            accountId
            monitorType
            tags {
              key
              values
            }
          }
        }
      }
    }
  }
}

Você pode consultar sua localização privada:

{
  actor {
    entitySearch(query: "domain = 'SYNTH' AND type = 'PRIVATE_LOCATION'") {
      results {
        entities {
          accountId
          guid
          name
          tags {
            key
            values
          }
        }
      }
    }
  }
}

Consulte monitor existente do período de inatividade. Os detalhes de configuração são armazenados na tag.

{
  actor {
    entitySearch(query: "domain = 'SYNTH' AND type = 'MONITOR_DOWNTIME'") {
      results {
        entities {
          accountId
          guid
          name
          tags {
            key
            values
          }
        }
      }
    }
  }
}

A consulta de credenciais seguras permite recuperar apenas metadados, mas não os valores das credenciais em si:

{
  actor {
    entitySearch(query: "domain = 'SYNTH' AND type = 'SECURE_CRED'") {
      results {
        entities {
          ... on SecureCredentialEntityOutline {
            accountId
            guid
            name
            tags {
              key
              values
            }
            updatedAt
          }
        }
      }
    }
  }
}

Recupere o script usado em uma API com script ou monitore o script do browser. Outros tipos de monitor retornarão um erro.

{
  actor {
    account(id: YOUR_ACCOUNT_ID) {
      synthetics {
        script(monitorGuid: "ENTITY_GUID") {
          text
        }
      }
    }
  }
}

Recupere as etapas configuradas para um monitor de etapas. Outros tipos de monitor retornarão um erro.

{
  actor {
    account(id: YOUR_ACCOUNT_ID) {
      synthetics {
        steps(monitorGuid: "ENTITY_GUID") {
          ordinal
          type
          values
        }
      }
    }
  }
}

Recupere o GUID da entidade para um monitor Sintético usando o ID do monitor.

{
  actor {
    entitySearch(
      query: "(domainId = 'MONITOR_ID')"
    ) {
      results {
        entities {
          ... on SyntheticMonitorEntityOutline {
            guid
            name
            monitorId
          }
        }
      }
    }
  }
}

Recuperar o status de todos os testes de atualização de tempo de execução para o monitor de tempo de execução legado. Esses testes preenchem a interface de atualizações de tempo de execução. O resultado do teste é armazenado na tag validationStatus . Se o teste de atualização falhar, a mensagem de erro estará disponível na tag validationError .

{
  actor {
    entitySearch(query: "domain = 'SYNTH' AND type = 'RUNTIME_VALIDATION'") {
      results {
        entities {
          accountId
          guid
          name
          tags {
            key
            values
          }
        }
      }
    }
  }
}

Recuperar o status de um teste de atualização de tempo de execução para um único monitor de tempo de execução legado. Esses resultados de teste preenchem a interface de atualizações de tempo de execução. O resultado do teste é armazenado na tag validationStatus . Se o teste de atualização falhar, a mensagem de erro estará disponível na tag validationError .

{
  actor {
    entitySearch(query: "domain = 'SYNTH' AND type = 'RUNTIME_VALIDATION' and domainId = 'MONITOR_ID'") {
      results {
        entities {
          accountId
          guid
          name
          tags {
            key
            values
          }
        }
      }
    }
  }
}

Crie seu monitor Sintético

Abaixo estão alguns exemplos de solicitações para automatizar a criação do seu monitor Sintético.

Dica

Inclua o objeto de tempo de execução que inclui runtimeType, runtimeTypeVersion e scriptLanguage para usar um tempo de execução mais recente. Não inclua o objeto de tempo de execução e estes atributos para continuar usando um tempo de execução legado.

O monitor de ping verifica se seu aplicativo está em execução. Aqui está um exemplo para criar um no NerdGraph:

mutation {
    syntheticsCreateSimpleMonitor (
      accountId: YOUR_ACCOUNT_ID 
      monitor: {
        locations: {
          public: ["LOCATION_1", "LOCATION_2"]
          }, 
        name: "YOUR_MONITOR_NAME", 
        period: PERIOD, 
        status: STATUS, 
        uri: "MONITORED_URI", 
        advancedOptions: {
          customHeaders: {
            name: "HEADER_NAME", 
            value: "HEADER_VALUE"
          }, 
          redirectIsFailure: REDIRECT_IS_FAILURE, 
          responseValidationText: "VALIDATION_TEXT", 
          shouldBypassHeadRequest: BYPASS_HEAD_REQUEST, 
          useTlsValidation: TLS_VALIDATION
        }, 
        apdexTarget: APDEX_TARGET
      }
  ) {
      errors {
        description
        type
      }
    }
  }

Monitor de browser simples usa instância do Chrome para imitar visitas de clientes. Aqui está um exemplo para criar um no NerdGraph:

mutation {
    syntheticsCreateSimpleBrowserMonitor (
      accountId: YOUR_ACCOUNT_ID, 
      monitor: {
        locations: {
          public: ["LOCATION_1", "LOCATION_2"]
          }, 
        name: "YOUR_MONITOR_NAME", 
        period: PERIOD, 
        runtime: {
          runtimeType: "RUNTIME_TYPE",
          runtimeTypeVersion: "RUNTIME_TYPE_VERSION",
          scriptLanguage: "SCRIPT_LANGUAGE"
        }
        status: STATUS, 
        uri: "MONITORED_URI", 
        advancedOptions: {
          customHeaders: {
            name: "HEADER_NAME", 
            value: "HEADER_VALUE"
          }, 
          enableScreenshotOnFailureAndScript: ENABLE_SCREENSHOT, 
          responseValidationText: "VALIDATION_TEXT", 
          useTlsValidation: TLS_VALIDATION
        }, 
        apdexTarget: APDEX_TARGET
      ) {
      errors {
        description
        type
      }
    }
  }

monitor de browser com script são interações mais complexas com suas páginas e aplicativos. Aqui está um exemplo para criar um no NerdGraph:

mutation {
    syntheticsCreateScriptBrowserMonitor (
      accountId: YOUR_ACCOUNT_ID, 
      monitor: { 
        locations: {
          public: ["LOCATION_1", "LOCATION_2"]
          }, 
        name: "MONITOR_NAME", 
        period: PERIOD,
        runtime: {
          runtimeType: "RUNTIME_TYPE",
          runtimeTypeVersion: "RUNTIME_TYPE_VERSION",
          scriptLanguage: "SCRIPT_LANGUAGE"
        }
        script: "SCRIPT_CONTENT", 
        status: STATUS, 
        advancedOptions: {
          enableScreenshotOnFailureAndScript: ENABLE_SCREENSHOT
        }, 
        apdexTarget: APDEX_TARGET
      }
    ) {
      errors {
        description
        type
      }
    }
  }

O monitor de API com script verifica seus endpoints de API. Aqui está um exemplo para criar um no NerdGraph:

mutation {
    syntheticsCreateScriptApiMonitor (
      accountId: YOUR_ACCOUNT_ID, 
      monitor: {
        locations: {
          public: ["LOCATION_1", "LOCATION_2"]
          }, 
        name: "YOUR_MONITOR_NAME", 
        period: PERIOD,
        runtime: {
          runtimeType: "RUNTIME_TYPE",
          runtimeTypeVersion: "RUNTIME_TYPE_VERSION",
          scriptLanguage: "SCRIPT_LANGUAGE"
        }
        script: "SCRIPT_CONTENT", 
        status: STATUS, 
        apdexTarget: APDEX_TARGET
      }
    ) {
      errors {
        description
        type
      }
    }
  }

O monitor de etapas fornece um monitor baseado em browser de várias etapas sem código. Aqui está um exemplo para criar um no NerdGraph:

mutation {
syntheticsCreateStepMonitor (
  accountId: NR_ACCOUNT_ID, 
  monitor: {
    locations: {
      public: ["LOCATION_1", "LOCATION_2"]
      },  
    name: "MONITOR_NAME", 
    period: PERIOD, 
    status: STATUS, 
    steps: [{
      ordinal: 0, 
      type: NAVIGATE, 
      values: ["MONITORED_URI"],["USER_AGENT"]
      },{
      ordinal: STEP_NUMBER,
      type: STEP_TYPE,
      values: ["CONDITIONAL_TYPE","VALUE"]
    }]
    advancedOptions: {
      enableScreenshotOnFailureAndScript: ENABLE_SCREENSHOT
    }, 
    apdexTarget: APDEX_TARGET
  }
) {
    errors {
      description
      type
    }
}
}

Configure o monitor para notificá-lo quando seu certificado SSL estiver prestes a expirar. Aqui está um exemplo para criar um no NerdGraph:

mutation {
    syntheticsCreateCertCheckMonitor (
      accountId: YOUR_ACCOUNT_ID, 
      monitor: {
        domain: "DOMAIN", 
        locations: {
          public: ["LOCATION_1", "LOCATION_2"]
          },
        name: "YOUR_MONITOR_NAME", 
        numberDaysToFailBeforeCertExpires: DAYS_UNTIL_EXPIRATION, 
        period: PERIOD, 
        status: STATUS, 
        apdexTarget: APDEX_TARGET
      }
    ) {
      errors {
        description
        type
      }
    }
  }

O monitor de links quebrados verifica se há falhas nos links de uma página da Web. Aqui está um exemplo para criar um no NerdGraph:

mutation {
  syntheticsCreateBrokenLinksMonitor (
    accountId: YOUR_ACCOUNT_ID, 
    monitor: {
      locations: {
        public: ["LOCATION_1", "LOCATION_2"]
        }, 
      name: "YOUR_MONITOR_NAME", 
      period: PERIOD, 
      status: STATUS, 
      apdexTarget: APDEX_TARGET, 
      uri: "MONITOR_URI", 
      tags: {
        key: "YOUR_TAG_NAME", 
        values: "TAG_VALUE"
        }
      }
    ) {
      errors {
        description
        type
      }
  }
}

Atualize seu monitor Sintético

Embora não seja possível alterar o tipo de monitor após criá-lo, você pode atualizar suas configurações. Somente o guia e as configurações que precisam ser atualizadas são necessárias como parte da solicitação.

Dica

Inclua o objeto de tempo de execução que inclui runtimeType, runtimeTypeVersion e scriptLanguage para atualizar um monitor para usar um tempo de execução mais recente. Inclua este objeto e defina esses atributos como uma string vazia para fazer downgrade para um tempo de execução legado. Não inclua este objeto e estes atributos para continuar usando um runtime legado.

Use isto para atualizar seu monitor de ping:

mutation {
  syntheticsUpdateSimpleMonitor (
    guid: "ENTITY_GUID", 
    monitor: {
      locations: {
        public: ["LOCATION_1", "LOCATION_2"]
      },  
      name: "YOUR_MONITOR_NAME", 
      period: PERIOD, 
      status: STATUS, 
      uri: "MONITORED_URI", 
      advancedOptions: {
        customHeaders: {
          name: "HEADER_NAME", 
          value: "HEADER_VALUE"
        }, 
        redirectIsFailure: REDIRECT_IS_FAILURE, 
        responseValidationText: "VALIDATION_TEXT", 
        shouldBypassHeadRequest: BYPASS_HEAD_REQUEST, 
        useTlsValidation: TLS_VALIDATION
      }, 
      apdexTarget: APDEX_TARGET
    }
  ) {
    errors {
      description
      type
    }
  }
}

Para atualizar um monitor de browser simples (incluindo a capacidade de atualizar a versão de tempo de execução), use isto:

mutation {
    syntheticsUpdateSimpleBrowserMonitor (
      guid: ENTITY_GUID, 
      monitor: {
        locations: {
          public: ["LOCATION_1", "LOCATION_2"]
          }, 
        name: "YOUR_MONITOR_NAME", 
        period: PERIOD, 
        runtime: {
          runtimeType: "RUNTIME_TYPE",
          runtimeTypeVersion: "RUNTIME_TYPE_VERSION",
          scriptLanguage: "SCRIPT_LANGUAGE"
        }
        status: STATUS, 
        uri: "MONITORED_URI", 
        advancedOptions: {
          customHeaders: {
            name: "HEADER_NAME", 
            value: "HEADER_VALUE"
          }, 
          enableScreenshotOnFailureAndScript: ENABLE_SCREENSHOT, 
          responseValidationText: "VALIDATION_TEXT", 
          useTlsValidation: TLS_VALIDATION
        }, 
        apdexTarget: APDEX_TARGET
      ) {
      errors {
        description
        type
      }
    }
  }

Para atualizar um script com do monitor do browser (incluindo a capacidade de atualizar a versão de tempo de execução), use isto:

mutation {
    syntheticsUpdateScriptBrowserMonitor (
      guid: ENTITY_GUID, 
      monitor: { 
        locations: {
          public: ["LOCATION_1", "LOCATION_2"]
          }, 
        name: "MONITOR_NAME", 
        period: PERIOD,
        runtime: {
          runtimeType: "RUNTIME_TYPE",
          runtimeTypeVersion: "RUNTIME_TYPE_VERSION",
          scriptLanguage: "SCRIPT_LANGUAGE"
        }
        script: "SCRIPT_CONTENT", 
        status: STATUS, 
        advancedOptions: {
          enableScreenshotOnFailureAndScript: ENABLE_SCREENSHOT
        }, 
        apdexTarget: APDEX_TARGET
      }
    ) {
      errors {
        description
        type
      }
    }
  }

Para atualizar um monitor de API com script (incluindo a capacidade de atualizar a versão de tempo de execução), use isto:

mutation {
    syntheticsUpdateScriptApiMonitor (
      guid: ENTITY_GUID, 
      monitor: {
        locations: {
          public: ["LOCATION_1", "LOCATION_2"]
          }, 
        name: "YOUR_MONITOR_NAME", 
        period: PERIOD,
        runtime: {
          runtimeType: "RUNTIME_TYPE",
          runtimeTypeVersion: "RUNTIME_TYPE_VERSION",
          scriptLanguage: "SCRIPT_LANGUAGE"
        }
        script: "SCRIPT_CONTENT", 
        status: STATUS, 
        apdexTarget: APDEX_TARGET
      }
    ) {
      errors {
        description
        type
      }
    }
  }

Use isto para atualizar um monitor de etapas:

mutation {
  syntheticsCreateStepMonitor (
    accountId: NR_ACCOUNT_ID, 
    monitor: {
      locations: {
        public: ["LOCATION_1", "LOCATION_2"]
        },  
      name: "MONITOR_NAME", 
      period: PERIOD, 
      status: STATUS, 
      steps: [{
        ordinal: 0, 
        type: NAVIGATE, 
        values: ["MONITORED_URI"],["USER_AGENT"]
        },{
        ordinal: STEP_NUMBER,
        type: STEP_TYPE,
        values: ["VALUE_1","VALUE_2"]
      }]
      advancedOptions: {
        enableScreenshotOnFailureAndScript: ENABLE_SCREENSHOT
      }, 
      apdexTarget: APDEX_TARGET
    }
  ) {
      errors {
        description
        type
      }
  }
}

Use isto para atualizar um monitor de verificação de certificado:

mutation {
    syntheticsUpdateCertCheckMonitor (
      guid: ENTITY_GUID, 
      monitor: {
        domain: "DOMAIN", 
        locations: {
          public: ["LOCATION_1", "LOCATION_2"]
          },
        name: "YOUR_MONITOR_NAME", 
        numberDaysToFailBeforeCertExpires: DAYS_UNTIL_EXPIRATION, 
        period: PERIOD, 
        status: STATUS, 
        apdexTarget: APDEX_TARGET
      }
    ) {
      errors {
        description
        type
      }
    }
  }

Use isto para atualizar um monitor de links quebrados:

mutation {
  syntheticsUpdateBrokenLinksMonitor (
    guid: ENTITY_GUID, 
    monitor: {
      locations: {
        public: ["LOCATION_1", "LOCATION_2"]
        }, 
      name: "YOUR_MONITOR_NAME", 
      period: PERIOD, 
      status: STATUS, 
      apdexTarget: APDEX_TARGET, 
      uri: "MONITOR_URI", 
      tags: {
        key: "YOUR_TAG_NAME", 
        values: "TAG_VALUE"
        }
      }
    ) {
      errors {
        description
        type
      }
  }
}

Você pode usar o exemplo abaixo para atualizar um browser simples, uma API com script ou monitorar o script do browser para os novos tempos de execução do Chrome 100+ ou Node.js 16.10. O exemplo a seguir atualiza um script monitor de browser com para o novo tempo de execução do tempo de execução legado.

Para atualizar um monitor de browser simples usando o exemplo abaixo, altere a mutação para syntheticsUpdateSimpleBrowserMonitor em vez de syntheticsUpdateScriptBrowserMonitor.

Para atualizar um monitor de API com script usando o exemplo abaixo, altere a mutação para syntheticsUpdateScriptApiMonitor em vez de syntheticsUpdateScriptBrowserMonitor.

Confira os campos opcionais para obter detalhes adicionais sobre as configurações de tempo de execução.

mutation {
  syntheticsUpdateScriptBrowserMonitor ( 
    guid: "<ENTITY_GUID>", 
    monitor: {
      runtime: {
        runtimeType: "RUNTIME_TYPE", 
        runtimeTypeVersion: "RUNTIME_TYPE_VERSION", 
        scriptLanguage: "SCRIPT_LANGUAGE"
        }
      }
    ) {
    errors {
      description
      type
    }
  }
}

Excluir um monitor Sintético

Use este script para excluir seu monitor:

Gerencie sua localização privada

A localização privada permite monitorar aplicativos atrás de seu firewall. Ao criar uma localização privada, você instala e configura o minion privado para executar o monitor atribuído a essa localização privada.

mutation{
  syntheticsCreatePrivateLocation (
    accountId: NR_ACCOUNT_ID,
    name: "PrivateLocationName",
    description: "Optional description",
    verifiedScriptExecution: false
  ) {
    guid
    errors {
      description
      type
    }
  }
}

mutation {
  syntheticsUpdatePrivateLocation (
    guid: YOUR_ENTITY_GUID,     
    description: "EnterYourDescription", 
    verifiedScriptExecution: true
  ) {
  description
  verifiedScriptExecution
  errors {
    description
    type
    }
  }
}

Gerencie suas credenciais seguras

Você usa credenciais seguras ao armazenar, proteger e gerenciar centralmente informações protegidas usadas pelo seu monitor, como senhas, chave de API ou certificados codificados. Usar o NerdGraph permite que você altere programaticamente os valores de suas credenciais seguras se precisar redefinir alguma credencial por qualquer motivo.

mutation {
  syntheticsCreateSecureCredential (
    accountId: YOUR_ENTITY_GUID, 
    description: "YourOptionalDescription", 
    key: SECURE_CREDENTIAL_NAME, 
    value: SECURE_CREDENTIAL_VALUE 
    ) {
    errors {
      description
    }
  }
}

mutation {
  syntheticsUpdateSecureCredential (
    accountId: YOUR_ACCOUNT_ID, 
    description: "YourOptionalDescription", 
    key: SECURE_CREDENTIAL_NAME, 
    value: SECURE_CREDENTIAL_VALUE) {
    createdAt
    lastUpdate
    errors {
      description
    }
  }
}

Gerencie o período de inatividade do seu monitor

Monitorar período de inatividade permite especificar horários em que seu Sintético deve parar de funcionar. Fornecemos diferentes trechos que demonstram como agendar o período de inatividade do monitor para o seu Sintético. Você precisa atualizar esses trechos para especificar o fuso horário, os horários de início e de término. Para saber mais sobre quando você pode agendar o período de inatividade do monitor, confira nosso documento Desativar monitoramento durante horários de manutenção programados. Para encontrar valores de fuso horário, consulte o banco de dados tz de fusos horários. Por exemplo, América/Los Angeles usaria a abreviatura PDT.

mutation {
  syntheticsCreateOnceMonitorDowntime (
    accountId: NR_ACCOUNT_ID,
    name: "MonitorDowntimeName",
    monitorGuids: ["OptionalMonitorEntityGuid", "OptionalMonitorEntityGuid"],
    timezone: "Timezone",
    startTime: "yyyy-MM-ddTHH:mm:ss",
    endTime: "yyyy-MM-ddTHH:mm:ss"
  ) {
    guid,
    accountId,
    name,
    monitorGuids,
    timezone,
    startTime,
    endTime
  }
}

mutation {
  syntheticsCreateDailyMonitorDowntime (
    accountId: NR_ACCOUNT_ID,
    name: "MonitorDowntimeName",
    monitorGuids: ["OptionalMonitorEntityGuid", "AnotherOptionalMonitorEntityGuid"],
    timezone: "Timezone",
    startTime: "yyyy-MM-ddTHH:mm:ss",
    endTime: "yyyy-MM-ddTHH:mm:ss",
    endRepeat: {
      onDate: "yyyy-MM-ddTHH:mm:ss",
      onRepeat: Int
    }
  ) {
    guid,
    accountId,
    name,
    monitorGuids,
    timezone,
    startTime,
    endTime,
    endRepeat {
      onDate,
      onRepeat
    }
  }
}

mutation {
  syntheticsCreateWeeklyMonitorDowntime (
    accountId: NR_ACCOUNT_ID,
    name: "MonitorDowntimeName",
    monitorGuids: ["OptionalMonitorEntityGuid", "AnotherOptionalMonitorEntityGuid"],
    timezone: "Timezone",
    startTime: "yyyy-MM-ddTHH:mm:ss",
    endTime: "yyyy-MM-ddTHH:mm:ss",
    endRepeat: {
      onDate: "yyyy-MM-ddTHH:mm:ss",
      onRepeat: Int
    },
    maintenanceDays: [WeekDaysEnums]
  ) {
    guid,
    accountId,
    name,
    monitorGuids,
    timezone,
    startTime,
    endTime,
    endRepeat {
      onDate,
      onRepeat
    },
    maintenanceDays
  }
}

mutation {
  syntheticsCreateMonthlyMonitorDowntime (
    accountId: NR_ACCOUNT_ID,
    name: "MonitorDowntimeName",
    monitorGuids: ["OptionalMonitorEntityGuid", "AnotherOptionalMonitorEntityGuid"],
    timezone: "Timezone",
    startTime: "yyyy-MM-ddTHH:mm:ss",
    endTime: "yyyy-MM-ddTHH:mm:ss",
    endRepeat: {
      onDate: "yyyy-MM-ddTHH:mm:ss",
      onRepeat: Int
    },
    frequency: {
      daysOfWeek: {
        weekDay: WeekDaysEnum,
        ordinalDayOfMonth: DayOfMonthOrdinal
      },
      daysOfMonth: [Int]
    }
  ) {
    guid,
    accountId,
    name,
    monitorGuids,
    timezone,
    startTime,
    endTime,
    endRepeat {
      onDate,
      onRepeat
    },
    frequency {
      daysOfWeek {
        weekDay,
        ordinalDayOfMonth
      },
      daysOfMonth
    }
  }
}

mutation {
  syntheticsEditMonitorDowntime (
    guid: "MonitorDowntimeEntityGuid",
    name: "MONITOR_DOWNTIME_NAME",
    monitorGuids: ["OptionalMonitorEntityGuid", "AnotherOptionalMonitorEntityGuid"],
    once: {
      timezone: "Timezone",
      startTime: "yyyy-MM-ddTHH:mm:ss",
      endTime: "yyyy-MM-ddTHH:mm:ss"
    },
    daily: {
      timezone: "Timezone",
      startTime: "yyyy-MM-ddTHH:mm:ss",
      endTime: "yyyy-MM-ddTHH:mm:ss",
      endRepeat: {
        onDate: "yyyy-MM-ddTHH:mm:ss",
        onRepeat: Int
      }
    },
    weekly: {
      timezone: "Timezone",
      startTime: "yyyy-MM-ddTHH:mm:ss",
      endTime: "yyyy-MM-ddTHH:mm:ss",
      endRepeat: {
        onDate: "yyyy-MM-ddTHH:mm:ss",
        onRepeat: Int
      },
      maintenanceDays: [WeekDaysEnums]
    },
    monthly: {
      timezone: "Timezone",
      startTime: "yyyy-MM-ddTHH:mm:ss",
      endTime: "yyyy-MM-ddTHH:mm:ss",
      endRepeat: {
        onDate: "yyyy-MM-ddTHH:mm:ss",
        onRepeat: Int
      },
      frequency: {
        daysOfWeek: {
          weekDay: WeekDaysEnum,
          ordinalDayOfMonth: DayOfMonthOrdinal
      },
      daysOfMonth: [Int]
    }
  ) {
    guid,
    accountId,
    name,
    monitorGuids,
    timezone,
    startTime,
    endTime,
    endRepeat {
      onDate,
      onRepeat
    },
    maintenanceDays,
    frequency {
      daysOfWeek {
        weekDay,
        ordinalDayOfMonth
      },
      daysOfMonth
    }
  }
}

Esta tradução de máquina é fornecida para sua comodidade.

Tutorial NerdGraph: Gerencie seu monitor Sintético

Requisitos .css-21sua1{background:none;border:none;width:0;padding:0;}

Entenda os campos no NerdGraph Explorer

Definir campos de período

Definir campos de tags

Definir campos opcionais

Use consulta para recuperar dados

Monitor de consulta

Consulta localização privada

Consultar monitor período de inatividade

Consultar credenciais seguras

Scriptdo monitor de consulta

Etapas do monitor de consulta

Consulta para mapear o ID do monitor para o GUID da entidade

Consulta para recuperar o status de todos os testes de atualização em tempo de execução

Consulta para recuperar o status de um teste de atualização em tempo de execução por ID monitor

Crie seu monitor Sintético

Dica

Crie um monitor de ping

Crie um monitor de browser simples

Crie um browser com script

Crie um monitor de API com script

Crie um monitor de passos

Crie um monitor de verificação de certificado

Crie um monitor de links quebrados

Atualize seu monitor Sintético

Dica

Atualizar um monitor de ping

Atualize um monitor de browser simples

Atualizar um script com do monitor do browser

Atualizar um monitor de teste de API

Atualizar um monitor de etapas

Atualizar um monitor de verificação de certificado

Atualizar um monitor de links quebrados

Atualizar o tempo de execução de um monitor

Excluir um monitor Sintético

Excluir monitor

Gerencie sua localização privada

Crie uma localização privada

Atualizar uma localização privada

Excluir um local privado

Limpar uma fila de trabalhos de localização privada

Gerencie suas credenciais seguras

Crie uma credencial segura

Atualizar uma credencial segura

Excluir uma credencial segura

Gerencie o período de inatividade do seu monitor

Crie um monitor de período de inatividade que seja executado uma vez

Crie um monitor de período de inatividade que seja executado diariamente

Crie um monitor de período de inatividade que seja executado semanalmente

Crie um período de inatividade do monitor que seja executado mensalmente

Atualizar um período de inatividade do monitor

Excluir um período de inatividade do monitor

Requisitos