Dies ist der AWS CDK v2-Entwicklerhandbuch. Das ältere CDK v1 wurde am 1. Juni 2022 in die Wartung aufgenommen und der Support wurde am 1. Juni 2023 eingestellt.
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Arbeiten Sie mit der AWS CDK-Bibliothek
Importieren und verwenden Sie die AWS Cloud Development Kit (AWS CDK) -Bibliothek, um Ihre AWS Cloud-Infrastruktur mit einer [unterstützten Programmiersprache](languages.md) zu definieren.
## Importieren Sie die AWS CDK-Bibliothek
Die [AWS CDK-Bibliothek](libraries.md) wird oft mit dem TypeScript Paketnamen bezeichnet. `aws-cdk-lib` Der tatsächliche Paketname variiert je nach Sprache. Im Folgenden finden Sie ein Beispiel für die Installation und den Import der CDK-Bibliothek:
**Example**
| | |
| --- |--- |
| **Install** | `npm install aws-cdk-lib` |
| **Import** | `import * as cdk from 'aws-cdk-lib';` |
| | |
| --- |--- |
| **Install** | `npm install aws-cdk-lib` |
| **Import** | `const cdk = require('aws-cdk-lib');` |
| | |
| --- |--- |
| **Install** | `python -m pip install aws-cdk-lib` |
| **Import** | `import aws_cdk as cdk` |
| | |
| --- |--- |
| **Hinein`pom.xml`, füge hinzu** | `Group software.amazon.awscdk; artifact aws-cdk-lib` |
| **Import** | `import software.amazon.awscdk.App;` |
| | |
| --- |--- |
| **Install** | `dotnet add package Amazon.CDK.Lib` |
| **Import** | `using Amazon.CDK;` |
| | |
| --- |--- |
| **Install** | `go get github.com/aws/aws-cdk-go/awscdk/v2` |
| **Import** | import (
"github.com/aws/aws-cdk-go/awscdk/v2"
)
|
Die `construct` Basisklasse und der unterstützende Code befinden sich in der `constructs` Bibliothek. Experimentelle Konstrukte, bei denen die API noch verfeinert wird, werden als separate Module verteilt.
## Verwenden der AWS CDK-API-Referenz
Verwenden Sie bei der Entwicklung mit dem [AWS CDK die AWS CDK-API-Referenz](libraries.md#libraries-reference).
Das Referenzmaterial der einzelnen Module ist in die folgenden Abschnitte unterteilt.
+ *Überblick*: Einführendes Material, das Sie benötigen, um mit dem Service im AWS CDK arbeiten zu können, einschließlich Konzepten und Beispielen.
+ *Konstrukte*: Bibliotheksklassen, die eine oder mehrere konkrete AWS Ressourcen repräsentieren. Dies sind die „kuratierten“ (L2) Ressourcen oder Muster (L3-Ressourcen), die eine übergeordnete Schnittstelle mit vernünftigen Standardeinstellungen bieten.
+ *Klassen: Klassen*, die keine Konstrukte sind und Funktionen bereitstellen, die von Konstrukten im Modul verwendet werden.
+ *Strukturen*: Datenstrukturen (Attributpakete), die die Struktur zusammengesetzter Werte wie Eigenschaften (das `props` Argument von Konstrukten) und Optionen definieren.
+ *Schnittstellen*: Schnittstellen, deren Namen alle mit „I“ beginnen, definieren die absolute Mindestfunktionalität für das entsprechende Konstrukt oder eine andere Klasse. Das CDK verwendet Konstruktschnittstellen, um AWS Ressourcen darzustellen, die außerhalb Ihrer AWS CDK-App definiert sind und auf die durch Methoden wie verwiesen wird. `Bucket.fromBucketArn()`
+ *Enums*: Sammlungen benannter Werte zur Angabe bestimmter Konstruktparameter. Die Verwendung eines Aufzählungswerts ermöglicht es dem CDK, diese Werte während der Synthese auf Gültigkeit zu überprüfen.
+ *CloudFormation Ressourcen*: Diese L1-Konstrukte, deren Namen mit „Cfn“ beginnen, stellen genau die in der Spezifikation definierten Ressourcen dar. CloudFormation Sie werden bei jeder CDK-Version automatisch anhand dieser Spezifikation generiert. Jedes L2- oder L3-Konstrukt kapselt eine oder mehrere Ressourcen. CloudFormation
+ *CloudFormation Eigenschaftstypen*: Die Sammlung benannter Werte, die die Eigenschaften für jede Ressource definieren. CloudFormation
## Schnittstellen im Vergleich zu Konstruktklassen
Das AWS CDK verwendet Schnittstellen auf eine bestimmte Art und Weise, die möglicherweise nicht offensichtlich ist, selbst wenn Sie mit Schnittstellen als Programmierkonzept vertraut sind.
Das AWS CDK unterstützt die Verwendung von Ressourcen, die außerhalb von CDK-Anwendungen definiert wurden, mit Methoden wie. `Bucket.fromBucketArn()` Externe Ressourcen können nicht geändert werden und verfügen möglicherweise nicht über alle Funktionen, die für Ressourcen verfügbar sind, die in Ihrer CDK-App definiert sind, z. B. mithilfe der Klasse. `Bucket` Schnittstellen stellen also die Mindestfunktionalität dar, die im CDK für einen bestimmten AWS Ressourcentyp verfügbar ist, *einschließlich externer* Ressourcen.
Wenn Sie Ressourcen in Ihrer CDK-App instanziieren, sollten Sie also immer konkrete Klassen wie verwenden. `Bucket` Wenn Sie den Typ eines Arguments angeben, das Sie in einem Ihrer eigenen Konstrukte akzeptieren, verwenden Sie den Schnittstellentyp, z. B. `IBucket` wenn Sie bereit sind, mit externen Ressourcen umzugehen (das heißt, Sie müssen sie nicht ändern). Wenn Sie ein CDK-definiertes Konstrukt benötigen, geben Sie den allgemeinsten Typ an, den Sie verwenden können.
Bei einigen Schnittstellen handelt es sich nicht um Konstrukte, sondern um Mindestversionen von Eigenschaften oder Optionspaketen, die bestimmten Klassen zugeordnet sind. Solche Schnittstellen können nützlich sein, wenn es darum geht, Unterklassen zu bilden, um Argumente zu akzeptieren, die Sie an Ihre übergeordnete Klasse weitergeben. Wenn Sie eine oder mehrere zusätzliche Eigenschaften benötigen, sollten Sie diese Schnittstelle oder einen spezifischeren Typ implementieren oder von ihr ableiten.
**Anmerkung**
Einige vom AWS CDK unterstützte Programmiersprachen verfügen nicht über eine Schnittstellenfunktion. In diesen Sprachen sind Schnittstellen ganz normale Klassen. Sie können sie anhand ihrer Namen identifizieren, die dem Muster eines anfänglichen „Ich“ folgen, gefolgt vom Namen eines anderen Konstrukts (z. B.`IBucket`). Es gelten die gleichen Regeln.
## Verwaltung von Abhängigkeiten
Abhängigkeiten für Ihre AWS CDK-App oder -Bibliothek werden mithilfe von Paketverwaltungstools verwaltet. Diese Tools werden häufig mit den Programmiersprachen verwendet.
In der Regel unterstützt das AWS CDK das standardmäßige oder offizielle Paketverwaltungstool der Sprache, falls es eines gibt. Andernfalls unterstützt das AWS CDK die beliebteste oder am häufigsten unterstützte Sprache. Möglicherweise können Sie auch andere Tools verwenden, insbesondere wenn diese mit den unterstützten Tools funktionieren. Die offizielle Unterstützung für andere Tools ist jedoch begrenzt.
Das AWS CDK unterstützt die folgenden Paketmanager:
| Sprache | Unterstütztes Paketverwaltungstool |
| --- | --- |
| TypeScript/JavaScript | NPM (Node Package Manager) oder Yarn |
| Python | PIP (Paketinstallationsprogramm für Python) |
| Java | Maven |
| C\# | NuGet |
| Go | Go-Module |
Wenn Sie mit dem AWS `cdk init` CDK-CLI-Befehl ein neues Projekt erstellen, werden Abhängigkeiten für die CDK-Kernbibliotheken und stabilen Konstrukte automatisch angegeben.
Weitere Informationen zur Verwaltung von Abhängigkeiten für unterstützte Programmiersprachen finden Sie im Folgenden:
+ [Verwaltung von Abhängigkeiten in TypeScript](work-with-cdk-typescript.md#work-with-cdk-typescript-dependencies).
+ [Verwaltung von Abhängigkeiten in JavaScript](work-with-cdk-javascript.md#work-with-cdk-javascript-dependencies).
+ [Verwaltung von Abhängigkeiten in Python](work-with-cdk-python.md#work-with-cdk-python-dependencies).
+ [Verwaltung von Abhängigkeiten in Java](work-with-cdk-java.md#work-with-cdk-java-dependencies).
+ [Abhängigkeiten in C\# verwalten](work-with-cdk-csharp.md#work-with-cdk-csharp-dependencies).
+ [Abhängigkeiten in Go verwalten](work-with-cdk-go.md#work-with-cdk-go-dependencies).
## Vergleich von AWS CDK in TypeScript mit anderen Sprachen
TypeScript war die erste Sprache, die für die Entwicklung von AWS CDK-Anwendungen unterstützt wurde. Daher ist eine beträchtliche Menge an CDK-Beispielcode geschrieben. TypeScript Wenn Sie in einer anderen Sprache entwickeln, kann es nützlich sein, die Implementierung von AWS CDK-Code mit der Sprache Ihrer Wahl zu TypeScript vergleichen. Dies kann Ihnen helfen, die Beispiele in der gesamten Dokumentation zu verwenden.
## Ein Modul importieren
**Example**
TypeScript unterstützt den Import eines ganzen Namespaces oder einzelner Objekte aus einem Namespace. Jeder Namespace enthält Konstrukte und andere Klassen zur Verwendung mit einem bestimmten Dienst. AWS
```
// Import main CDK library as cdk
import * as cdk from 'aws-cdk-lib'; // ES6 import preferred in TS
const cdk = require('aws-cdk-lib'); // Node.js require() preferred in JS
// Import specific core CDK classes
import { Stack, App } from 'aws-cdk-lib';
const { Stack, App } = require('aws-cdk-lib');
// Import AWS S3 namespace as s3 into current namespace
import { aws_s3 as s3 } from 'aws-cdk-lib'; // TypeScript
const s3 = require('aws-cdk-lib/aws-s3'); // JavaScript
// Having imported cdk already as above, this is also valid
const s3 = cdk.aws_s3;
// Now use s3 to access the S3 types
const bucket = s3.Bucket(...);
// Selective import of s3.Bucket
import { Bucket } from 'aws-cdk-lib/aws-s3'; // TypeScript
const { Bucket } = require('aws-cdk-lib/aws-s3'); // JavaScript
// Now use Bucket to instantiate an S3 bucket
const bucket = Bucket(...);
```
TypeScriptEbenso unterstützt Python Modulimporte mit Namespaces und selektive Importe. **Namespaces in Python sehen aus wie aws\_cdk.** *xxx*, wobei *xxx* für einen AWS Servicenamen steht, z. B. **s3** für Amazon S3. (In diesen Beispielen wird Amazon S3 verwendet).
```
# Import main CDK library as cdk
import aws_cdk as cdk
# Selective import of specific core classes
from aws_cdk import Stack, App
# Import entire module as s3 into current namespace
import aws_cdk.aws_s3 as s3
# s3 can now be used to access classes it contains
bucket = s3.Bucket(...)
# Selective import of s3.Bucket into current namespace
from aws_cdk.s3 import Bucket
# Bucket can now be used to instantiate a bucket
bucket = Bucket(...)
```
Die Importe von Java funktionieren anders als TypeScript die von. Jede Import-Anweisung importiert entweder einen einzelnen Klassennamen aus einem bestimmten Paket oder alle in diesem Paket definierten Klassen (using`\*`). Auf Klassen kann entweder über den Klassennamen selbst zugegriffen werden, falls er importiert wurde, oder über den *qualifizierten* Klassennamen einschließlich des zugehörigen Pakets.
Bibliotheken werden wie `software.amazon.awscdk.services.xxx` die AWS Construct-Bibliothek benannt (die Hauptbibliothek ist`software.amazon.awscdk`). Die Maven-Gruppen-ID für AWS CDK-Pakete lautet. `software.amazon.awscdk`
```
// Make certain core classes available
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.App;
// Make all Amazon S3 construct library classes available
import software.amazon.awscdk.services.s3.*;
// Make only Bucket and EventType classes available
import software.amazon.awscdk.services.s3.Bucket;
import software.amazon.awscdk.services.s3.EventType;
// An imported class may now be accessed using the simple class name (assuming that name
// does not conflict with another class)
Bucket bucket = Bucket.Builder.create(...).build();
// We can always use the qualified name of a class (including its package) even without an
// import directive
software.amazon.awscdk.services.s3.Bucket bucket =
software.amazon.awscdk.services.s3.Bucket.Builder.create(...)
.build();
// Java 10 or later can use var keyword to avoid typing the type twice
var bucket =
software.amazon.awscdk.services.s3.Bucket.Builder.create(...)
.build();
```
In C\# importieren Sie Typen mit der Direktive. `using` Es gibt zwei Stile. Mit einem erhalten Sie Zugriff auf alle Typen im angegebenen Namespace, indem Sie deren Klarnamen verwenden. Mit dem anderen können Sie mithilfe eines Alias auf den Namespace selbst verweisen.
Pakete werden wie AWS Construct `Amazon.CDK.AWS.xxx` Library-Pakete benannt. (Das Kernmodul ist`Amazon.CDK`.)
```
// Make CDK base classes available under cdk
using cdk = Amazon.CDK;
// Make all Amazon S3 construct library classes available
using Amazon.CDK.AWS.S3;
// Now we can access any S3 type using its name
var bucket = new Bucket(...);
// Import the S3 namespace under an alias
using s3 = Amazon.CDK.AWS.S3;
// Now we can access an S3 type through the namespace alias
var bucket = new s3.Bucket(...);
// We can always use the qualified name of a type (including its namespace) even without a
// using directive
var bucket = new Amazon.CDK.AWS.S3.Bucket(...);
```
Jedes AWS Construct Library-Modul wird als Go-Paket bereitgestellt.
```
import (
"github.com/aws/aws-cdk-go/awscdk/v2" // CDK core package
"github.com/aws/aws-cdk-go/awscdk/v2/awss3" // AWS S3 construct library module
)
// now instantiate a bucket
bucket := awss3.NewBucket(...)
// use aliases for brevity/clarity
import (
cdk "github.com/aws/aws-cdk-go/awscdk/v2" // CDK core package
s3 "github.com/aws/aws-cdk-go/awscdk/v2/awss3" // AWS S3 construct library module
)
bucket := s3.NewBucket(...)
```
## Ein Konstrukt instanziieren
AWS CDK-Konstruktklassen haben in allen unterstützten Sprachen denselben Namen. Die meisten Sprachen verwenden das `new` Schlüsselwort, um eine Klasse zu instanziieren (Python und Go nicht). Außerdem `this` bezieht sich das Schlüsselwort in den meisten Sprachen auf die aktuelle Instanz. (Python verwendet `self` konventionell.) Sie sollten jedem Konstrukt, das Sie erstellen, einen Verweis auf die aktuelle Instanz als `scope` Parameter übergeben.
Das dritte Argument für ein AWS CDK-Konstrukt ist ein Objekt`props`, das Attribute enthält, die zum Erstellen des Konstrukts benötigt werden. Dieses Argument kann optional sein, aber wenn es erforderlich ist, behandeln die unterstützten Sprachen es auf idiomatische Weise. Die Namen der Attribute sind ebenfalls an die Standardbenennungsmuster der Sprache angepasst.
**Example**
```
// Instantiate default Bucket
const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket');
// Instantiate Bucket with bucketName and versioned properties
const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket', {
bucketName: 'amzn-s3-demo-bucket',
versioned: true,
});
// Instantiate Bucket with websiteRedirect, which has its own sub-properties
const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket', {
websiteRedirect: {host: 'aws.amazon.com'}});
```
Python verwendet beim Instanziieren einer Klasse kein `new` Schlüsselwort. Das Eigenschaftenargument wird mit Schlüsselwortargumenten dargestellt, und die Argumente werden mit benannt. `snake_case`
Wenn ein Props-Wert selbst ein Bündel von Attributen ist, wird er durch eine nach der Eigenschaft benannte Klasse repräsentiert, die Schlüsselwortargumente für die Untereigenschaften akzeptiert.
In Python wird die aktuelle Instanz als erstes Argument an Methoden übergeben, das `self` per Konvention benannt ist.
```
# Instantiate default Bucket
bucket = s3.Bucket(self, "amzn-s3-demo-bucket")
# Instantiate Bucket with bucket_name and versioned properties
bucket = s3.Bucket(self, "amzn-s3-demo-bucket", bucket_name="amzn-s3-demo-bucket", versioned=true)
# Instantiate Bucket with website_redirect, which has its own sub-properties
bucket = s3.Bucket(self, "amzn-s3-demo-bucket", website_redirect=s3.WebsiteRedirect(
host_name="aws.amazon.com"))
```
In Java wird das Argument props durch eine Klasse mit dem Namen repräsentiert `XxxxProps` (z. B. für die Requisiten des `Bucket` Konstrukts). `BucketProps` Sie erstellen das Argument props mithilfe eines Builder-Musters.
Jede `XxxxProps` Klasse hat einen Builder. Außerdem gibt es für jedes Konstrukt einen praktischen Builder, der die Requisiten und das Konstrukt in einem Schritt erstellt, wie im folgenden Beispiel gezeigt.
Requisiten haben den gleichen Namen wie in TypeScript, using. `camelCase`
```
// Instantiate default Bucket
Bucket bucket = Bucket(self, "amzn-s3-demo-bucket");
// Instantiate Bucket with bucketName and versioned properties
Bucket bucket = Bucket.Builder.create(self, "amzn-s3-demo-bucket")
.bucketName("amzn-s3-demo-bucket").versioned(true)
.build();
# Instantiate Bucket with websiteRedirect, which has its own sub-properties
Bucket bucket = Bucket.Builder.create(self, "amzn-s3-demo-bucket")
.websiteRedirect(new websiteRedirect.Builder()
.hostName("aws.amazon.com").build())
.build();
```
In C\# werden Requisiten mithilfe eines Objektinitialisierers für eine Klasse mit dem Namen `XxxxProps` (z. B. für die Requisiten des `Bucket` Konstrukts) angegeben. `BucketProps`
Requisiten werden ähnlich benannt wie, außer mit TypeScript `PascalCase`
Es ist praktisch, das `var` Schlüsselwort bei der Instanziierung eines Konstrukts zu verwenden, sodass Sie den Klassennamen nicht zweimal eingeben müssen. Ihr lokaler Code-Styleguide kann jedoch variieren.
```
// Instantiate default Bucket
var bucket = Bucket(self, "amzn-s3-demo-bucket");
// Instantiate Bucket with BucketName and Versioned properties
var bucket = Bucket(self, "amzn-s3-demo-bucket", new BucketProps {
BucketName = "amzn-s3-demo-bucket",
Versioned = true});
// Instantiate Bucket with WebsiteRedirect, which has its own sub-properties
var bucket = Bucket(self, "amzn-s3-demo-bucket", new BucketProps {
WebsiteRedirect = new WebsiteRedirect {
HostName = "aws.amazon.com"
}});
```
Um ein Konstrukt in Go zu erstellen, rufen Sie die Funktion auf, `NewXxxxxx` bei der der Name des Konstrukts `Xxxxxxx` steht. Die Eigenschaften der Konstrukte sind als Struktur definiert.
In Go sind alle Konstruktparameter Zeiger, einschließlich Werte wie Zahlen, Boolesche Werte und Zeichenketten. Verwenden Sie die Komfortfunktionen wie, `jsii.String` um diese Zeiger zu erstellen.
```
// Instantiate default Bucket
bucket := awss3.NewBucket(stack, jsii.String("amzn-s3-demo-bucket"), nil)
// Instantiate Bucket with BucketName and Versioned properties
bucket1 := awss3.NewBucket(stack, jsii.String("amzn-s3-demo-bucket"), &awss3.BucketProps{
BucketName: jsii.String("amzn-s3-demo-bucket"),
Versioned: jsii.Bool(true),
})
// Instantiate Bucket with WebsiteRedirect, which has its own sub-properties
bucket2 := awss3.NewBucket(stack, jsii.String("amzn-s3-demo-bucket"), &awss3.BucketProps{
WebsiteRedirect: &awss3.RedirectTarget{
HostName: jsii.String("aws.amazon.com"),
}})
```
## Auf Mitglieder zugreifen
Es ist üblich, auf Attribute oder Eigenschaften von Konstrukten und anderen AWS CDK-Klassen zu verweisen und diese Werte beispielsweise als Eingaben zum Erstellen anderer Konstrukte zu verwenden. Die zuvor für Methoden beschriebenen Namensunterschiede gelten auch hier. Außerdem ist es in Java nicht möglich, direkt auf Mitglieder zuzugreifen. Stattdessen wird eine Getter-Methode bereitgestellt.
**Example**
Namen sind`camelCase`.
```
bucket.bucketArn
```
Namen sind`snake_case`.
```
bucket.bucket_arn
```
Für jede Eigenschaft steht eine Getter-Methode zur Verfügung; diese Namen sind`camelCase`.
```
bucket.getBucketArn()
```
Namen sind`PascalCase`.
```
bucket.BucketArn
```
Namen sind`PascalCase`.
```
bucket.BucketArn
```
## Enum-Konstanten
Enum-Konstanten sind auf eine Klasse beschränkt und haben in allen Sprachen Großbuchstaben mit Unterstrichen (manchmal auch als bezeichnet). `SCREAMING_SNAKE_CASE` Da Klassennamen auch in allen unterstützten Sprachen außer Go dieselbe Groß- und Kleinschreibung verwenden, sind qualifizierte Aufzählungsnamen auch in diesen Sprachen identisch.
```
s3.BucketEncryption.KMS_MANAGED
```
In Go sind Enum-Konstanten Attribute des Modul-Namespaces und werden wie folgt geschrieben.
```
awss3.BucketEncryption_KMS_MANAGED
```
## Objektschnittstellen
Das AWS CDK verwendet TypeScript Objektschnittstellen, um anzuzeigen, dass eine Klasse einen erwarteten Satz von Methoden und Eigenschaften implementiert. Sie erkennen eine Objektschnittstelle daran, dass ihr Name mit `I` beginnt. Eine konkrete Klasse gibt die Schnittstellen an, die sie mithilfe des `implements` Schlüsselworts implementiert.
**Example**
JavaScript hat keine Schnittstellenfunktion. Sie können das `implements` Schlüsselwort und die darauf folgenden Klassennamen ignorieren.
```
import { IAspect, IConstruct } from 'aws-cdk-lib';
class MyAspect implements IAspect {
public visit(node: IConstruct) {
console.log('Visited', node.node.path);
}
}
```
Python hat keine Schnittstellenfunktion. Für das AWS CDK können Sie jedoch die Implementierung der Schnittstelle angeben, indem Sie Ihre Klasse mit `@jsii.implements(interface)` dekorieren.
```
from aws_cdk import IAspect, IConstruct
import jsii
@jsii.implements(IAspect)
class MyAspect():
def visit(self, node: IConstruct) -> None:
print("Visited", node.node.path)
```
```
import software.amazon.awscdk.IAspect;
import software.amazon.awscdk.IConstruct;
public class MyAspect implements IAspect {
public void visit(IConstruct node) {
System.out.format("Visited %s", node.getNode().getPath());
}
}
```
```
using Amazon.CDK;
public class MyAspect : IAspect
{
public void Visit(IConstruct node)
{
System.Console.WriteLine($"Visited ${node.Node.Path}");
}
}
```
Go-Strukturen müssen nicht explizit deklarieren, welche Schnittstellen sie implementieren. Der Go-Compiler bestimmt die Implementierung auf der Grundlage der in der Struktur verfügbaren Methoden und Eigenschaften. `MyAspect`Implementiert beispielsweise im folgenden Code die `IAspect` Schnittstelle, weil sie eine `Visit` Methode bereitstellt, die ein Konstrukt benötigt.
```
type MyAspect struct {
}
func (a MyAspect) Visit(node constructs.IConstruct) {
fmt.Println("Visited", *node.Node().Path())
}
```