Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Scrivere uno script canary usando il runtime Java

Struttura del progetto Java per un canarino

Per creare un canarino in Java, devi scrivere il codice, compilarlo e distribuire gli artefatti compilati su Synthetics. È possibile inizializzare un progetto Java Lambda in vari modi. Ad esempio, puoi utilizzare una configurazione di progetto Java standard nel tuo IDE preferito, come IntelliJ IDEA o Visual Studio Code. In alternativa, è possibile creare manualmente la struttura di file richiesta.

Un progetto Java Synthetics contiene la seguente struttura generale:

/project-root
    └ src
        └ main
            └ java
                └ canarypackage // name of package
                |    └ ExampleCanary.java // Canary code file
                |    └ other_supporting_classes
                - resources
                     └ synthetics.json // Synthetics configuration file    
     └ build.gradle OR pom.xml

Puoi usare Maven o Gradle per creare il tuo progetto e gestire le dipendenze.

Nella struttura precedente, la ExampleCanary classe è il punto di ingresso o il gestore del canarino.

Esempio di classe Java Canary

Questo esempio prevede che un canarino effettui una richiesta get a un URL memorizzato nella variabile di ambiente TESTING_URL Lambda. Il canarino non utilizza nessuno dei metodi forniti dal runtime Synthetics.

package canarypackage;

import java.net.HttpURLConnection;
import java.net.URL;

// Handler value: canary.ExampleCanary::canaryCode
public class ExampleCanary { 
  public void canaryCode() throws Exception{ 
      URL url = new URL(System.getenv("TESTING_URL"));
      HttpURLConnection con=(HttpURLConnection)url.openConnection();
      con.setRequestMethod("GET");
      con.setConnectTimeout(5000);
      con.setReadTimeout(5000);
      int status=con.getResponseCode();
      if(status!=200){
        throw new Exception("Failed to load " + url + ", status code: " + status);
      }
  }
} 

Si consiglia vivamente di modularizzare i canarini utilizzando la funzione di libreria fornita da Synthetics. executeStep Il canarino effettua get chiamate verso due variabili di origine e ambiente separate URLs . URL1 URL2

package canarypackage;

import com.amazonaws.synthetics.Synthetics;
import java.net.HttpURLConnection;
import java.net.URL;

// Handler value: canary.ExampleCanary::canaryCode
public class ExampleCanary {
  public void canaryCode(Synthetics synthetics) throws Exception {
    createStep("Step1", synthetics, System.getenv("URL1"));
    createStep("Step2", synthetics, System.getenv("URL2"));
    return;
  }
  
  private void createStep(String stepName, Synthetics synthetics, String url) throws Exception{
    synthetics.executeStep(stepName,()->{
      URL obj=new URL(url);
      HttpURLConnection con=(HttpURLConnection)obj.openConnection();
      con.setRequestMethod("GET");
      con.setConnectTimeout(5000);
      con.setReadTimeout(5000);
      int status=con.getResponseCode();
      if(status!=200){
        throw new Exception("Failed to load" + url + "status code:" + status);
      }
      return null;
    }).get();
  }
}

Imballaggio del progetto per un canarino

Synthetics accetta il codice per un java canary in formato zip. Lo zip è composto dai file di classe per il codice canario, dai jar per eventuali dipendenze di terze parti e dal file di configurazione Synthetics.

Un zip Java Synthetics contiene la seguente struttura generale.

example-canary
    └ lib
    |  └ //third party dependency jars
       └ java-canary.jar
    └ synthetics.json

Per creare questo zip dalla struttura del progetto precedente, puoi usare gradle (build.gradle) o maven (pom.xml). Ecco un esempio.

Per informazioni sulle dipendenze o sulle interfacce in fase di compilazione per la libreria Synthetics, vedere il README in -java. aws-cloudwatch-synthetics-sdk

plugins {
    id 'java'
}

repositories {
    mavenCentral()
}

dependencies {
    // Third party dependencies 
    // example: implementation 'software.amazon.awssdk:s3:2.31.9'
    
    // Declares dependency on Synthetics interfaces for compiling only
    // Refer https://github.com/aws/aws-cloudwatch-synthetics-sdk-java for building from source.
    compileOnly 'software.amazon.synthetics:aws-cloudwatch-synthetics-sdk-java:1.0.0'}

test {
    useJUnitPlatform()
}

// Build the zip to be used as Canary code.
task buildZip(type: Zip) {

    archiveFileName.set("example-canary.zip")
    destinationDirectory.set(file("$buildDir"))
    
    from processResources
    into('lib') {
        from configurations.runtimeClasspath
        from(tasks.named("jar"))
    }
    from "src/main/java/resources/synthetics.json"
    
    doLast {
        println "Artifact written to: ${archiveFile.get().asFile.absolutePath}"
    }
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
}

tasks.named("build") {
    dependsOn "buildZip"
}

Nome del gestore

Il nome del gestore è il punto di ingresso per il canarino. Per il runtime Java, il gestore ha il seguente formato.

<<full qualified name for canary class>>::<<name of the method to start the execution from>>
// for above code: canarypackage.ExampleCanary::canaryCode

CloudWatch Configurazioni Synthetics

È possibile configurare il comportamento del runtime Java Synthetics fornendo un file di configurazione JSON opzionale denominato. synthetics.json Questo file deve essere impacchettato nella directory principale del pacchetto zip. Sebbene un file di configurazione sia facoltativo, se non lo fornite o se manca una chiave di configurazione, CloudWatch utilizza i valori predefiniti.

Di seguito sono riportati i valori di configurazione supportati e i relativi valori predefiniti.

{
    "step": {
        "stepSuccessMetric": true,
        "stepDurationMetric": true,
        "continueOnStepFailure": false,
        "stepsReport": true
    },
    "logging": {
        "logRequest": false,
        "logResponse": false
    },
    "httpMetrics": {
        "metric_2xx": true,
        "metric_4xx": true,
        "metric_5xx": true,
        "aggregated2xxMetric": true,
        "aggregated4xxMetric": true,
        "aggregated5xxMetric": true
    },
    "canaryMetrics": {
        "failedCanaryMetric": true,
        "aggregatedFailedCanaryMetric": true
    }
}

Configurazioni dei passaggi

Configurazioni di registrazione

Si applica ai log generati da CloudWatch Synthetics. Controlla la verbosità dei registri di richieste e risposte.

Configurazioni metriche HTTP

Configurazioni per le metriche relative al conteggio delle richieste di rete con codici di stato HTTP diversi, emesse da Synthetics CloudWatch per questo canarino.

Configurazioni metriche Canary

Configurazioni per altre metriche emesse da Synthetics. CloudWatch

CloudWatch Variabili di ambiente Synthetics

È possibile configurare il livello e il formato di registrazione utilizzando le variabili di ambiente.

Formato del registro

Il CloudWatch runtime Java Synthetics CloudWatch crea registri per ogni esecuzione di Canary. I log sono scritti in formato JSON per facilitare le interrogazioni. Facoltativamente, è possibile modificare il formato del registro in TESTO.

Livelli di registro

Oltre alle variabili di ambiente di cui sopra, è stata aggiunta una variabile di ambiente predefinita per il runtime Java, variabile di AWS_LAMBDA-EXEC_WRAPPER ambiente alla funzione, e il suo valore è impostato su/opt/synthetics-otel-instrument. Questa variabile di ambiente modifica il comportamento di avvio della funzione per la telemetria. Se questa variabile di ambiente esiste già, assicurati che sia impostata sul valore richiesto.