Freigeben über

Azure Key Vault Certificates Client-Bibliothek für JavaScript - Version 4.10.3

Azure Key Vault ist ein Cloud-Dienst, der sichere Speicherung und automatisierte Verwaltung von Zertifikaten bietet, die in einer Cloud-Anwendung verwendet werden. Mehrere Zertifikate und mehrere Versionen desselben Zertifikats können im Azure Key Vault aufbewahrt werden. Jedes Zertifikat im Tresor verfügt über eine Richtlinie, die die Ausstellung und Lebensdauer des Zertifikats steuert, zusammen mit Aktionen, die als Zertifikate im Nahen Ablauf ausgeführt werden sollen.

Wenn Sie mehr über Azure Key Vault erfahren möchten, möchten Sie vielleicht folgendes lesen: Was ist Azure Key Vault?

Nutzen Sie die Client-Bibliothek für Azure Key Vault Zertifikate in Ihrer Node.js Anwendung, um:

  • Abrufen, Festlegen und Löschen eines Zertifikats.
  • Aktualisieren Sie ein Zertifikat, seine Attribute, Aussteller, Richtlinien, Vorgänge und Kontakte.
  • Sichern und Wiederherstellen eines Zertifikats.
  • Dient zum Abrufen, Löschen oder Wiederherstellen eines gelöschten Zertifikats.
  • Rufen Sie alle Versionen eines Zertifikats ab.
  • Abrufen aller Zertifikate.
  • Ruft alle gelöschten Zertifikate ab.

Hinweis: Dieses Paket kann im Browser aufgrund Azure Key Vault Servicebeschränkungen nicht verwendet werden; siehe bitte dieses Dokument zur Orientierung.

Wichtige Links:

Erste Schritte

Derzeit unterstützte Umgebungen

Voraussetzungen

Installieren des Pakets

Installieren Sie die Client-Bibliothek Azure Key Vault Certificates mit npm

npm install @azure/keyvault-certificates

Installieren der Identitätsbibliothek

Key Vault-Clients authentifizieren sich über die Azure Identity Library. Installieren sie auch mithilfe von npm

npm install @azure/identity

Konfigurieren von TypeScript

TypeScript-Benutzer müssen Knotentypdefinitionen installiert haben:

npm install @types/node

Sie müssen auch compilerOptions.allowSyntheticDefaultImports in Ihrem tsconfig.jsonaktivieren. Wenn Sie compilerOptions.esModuleInteropaktiviert haben, ist allowSyntheticDefaultImports standardmäßig aktiviert. Weitere Informationen finden Sie im Compileroptionenhandbuch TypeScript.

Authentifizierung mit Azure Active Directory

Der Key Vault-Dienst ist auf Azure Active Directory angewiesen, um Anfragen an seine APIs zu authentifizieren. Das @azure/identity-Paket bietet eine Vielzahl von Anmeldeinformationstypen, die Ihre Anwendung verwenden kann, um dies zu tun. Die README für @azure/identity bietet weitere Details und Beispiele zum Einstieg.

Um mit dem Azure Key Vault-Dienst zu interagieren, musst du eine Instanz der CertificateClient-Klasse, eine vault-URL und ein Zugangsdatenobjekt erstellen. In den Beispielen in diesem Dokument wird ein Anmeldeinformationsobjekt namens DefaultAzureCredentialverwendet, das für die meisten Szenarien geeignet ist, einschließlich lokaler Entwicklungs- und Produktionsumgebungen. Darüber hinaus empfehlen wir die Verwendung einer verwalteten Identität für die Authentifizierung in Produktionsumgebungen.

Weitere Informationen zu verschiedenen Authentifizierungsmethoden und deren entsprechenden Zugangsarten finden Sie in der Azure Identitätsdokumentation.

Hier ist ein schnelles Beispiel. Importieren Sie zunächst DefaultAzureCredential und CertificateClient. Sobald diese importiert wurden, können wir als Nächstes eine Verbindung mit dem Schlüsseltresordienst herstellen:

import { DefaultAzureCredential } from "@azure/identity";
import { CertificateClient } from "@azure/keyvault-certificates";

const credential = new DefaultAzureCredential();

// Build the URL to reach your key vault
const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

// Lastly, create our certificates client and connect to the service
const client = new CertificateClient(url, credential);

Schlüsselkonzepte

  • Der Certificates client ist die primäre Schnittstelle zur Interaktion mit den API-Methoden, die mit Zertifikaten in der Azure Key Vault API aus einer JavaScript-Anwendung zusammenhängen. Nach der Initialisierung stellt sie einen grundlegenden Satz von Methoden bereit, die zum Erstellen, Lesen, Aktualisieren und Löschen von Zertifikaten verwendet werden können.
  • Eine Zertifikatsversion ist eine Version eines Zertifikats im Key Vault. Jedes Mal, wenn ein Benutzer einem eindeutigen Zertifikatnamen einen Wert zuweist, wird eine neue Version dieses Zertifikats erstellt. Wenn Sie ein Zertifikat anhand eines Namens abrufen, wird immer der neueste Wert zurückgegeben, es sei denn, eine bestimmte Version wird der Abfrage bereitgestellt.
  • soft delete ermöglicht Es Key Vaults, das Löschen und Löschen als zwei separate Schritte zu unterstützen, sodass gelöschte Zertifikate nicht sofort verloren gehen. Das passiert nur, wenn der Key Vault soft-delete aktiviert hat.
  • Eine Zertifikatsicherung kann aus jedem erstellten Zertifikat generiert werden. Diese Sicherungen sind binärdaten und können nur verwendet werden, um ein zuvor gelöschtes Zertifikat neu zu generieren.

Spezifizierung der Azure Key Vault Service API-Version

Standardmäßig verwendet dieses Paket die neueste Azure Key Vault Service-Version, nämlich 7.1. Die einzige unterstützte Version ist 7.0. Sie können die verwendete Dienstversion ändern, indem Sie die Option serviceVersion im Clientkonstruktor wie unten gezeigt festlegen:

import { DefaultAzureCredential } from "@azure/identity";
import { CertificateClient } from "@azure/keyvault-certificates";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

// Change the Azure Key Vault service API version being used via the `serviceVersion` option
const client = new CertificateClient(url, credential, {
  serviceVersion: "7.5",
});

Beispiele

Die folgenden Abschnitte enthalten Codeschnipsel, die einige der gängigen Aufgaben unter Verwendung von Azure Key Vault-Zertifikaten abdecken. Die hier behandelten Szenarien bestehen aus:

Erstellen und Festlegen eines Zertifikats

beginCreateCertificate erstellt ein Zertifikat, das im Azure Key Vault gespeichert werden soll. Wenn bereits ein Zertifikat mit demselben Namen vorhanden ist, wird eine neue Version des Zertifikats erstellt.

import { DefaultAzureCredential } from "@azure/identity";
import { CertificateClient } from "@azure/keyvault-certificates";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new CertificateClient(url, credential);

const certificateName = "MyCertificateName";

// Note: Sending `Self` as the `issuerName` of the certificate's policy will create a self-signed certificate.
await client.beginCreateCertificate(certificateName, {
  issuerName: "Self",
  subject: "cn=MyCert",
});

Neben dem Namen des Zertifikats und der Richtlinie können Sie auch die folgenden Eigenschaften in einem dritten Argument mit optionalen Werten übergeben:

  • enabled: Ein boolescher Wert, der bestimmt, ob das Zertifikat verwendet werden kann oder nicht.
  • tags: Jeder Satz von Schlüsselwerten, die zum Suchen und Filtern von Zertifikaten verwendet werden können.
import { DefaultAzureCredential } from "@azure/identity";
import { CertificateClient } from "@azure/keyvault-certificates";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new CertificateClient(url, credential);

const certificateName = "MyCertificateName";

// Note: Sending `Self` as the `issuerName` of the certificate's policy will create a self-signed certificate.
const certificatePolicy = {
  issuerName: "Self",
  subject: "cn=MyCert",
};
const enabled = true;
const tags = {
  myCustomTag: "myCustomTagsValue",
};

await client.beginCreateCertificate(certificateName, certificatePolicy, {
  enabled,
  tags,
});

Durch das Aufrufen von beginCreateCertificate mit demselben Namen wird eine neue Version desselben Zertifikats erstellt, die über die neuesten bereitgestellten Attribute verfügt.

Da Zertifikate einige Zeit in Anspruch nehmen, um vollständig erstellt zu werden, gibt beginCreateCertificate ein Pollerobjekt zurück, das den zugrunde liegenden Long Running-Vorgang gemäß unseren Richtlinien nachverfolgt: https://azure.github.io/azure-sdk/typescript_design.html#ts-lro

Mit dem empfangenen Abrufer können Sie das erstellte Zertifikat abrufen, indem Sie poller.getResult()aufrufen. Sie können auch warten, bis der Löschvorgang abgeschlossen ist, entweder indem Sie einzelne Dienstaufrufe ausführen, bis das Zertifikat erstellt wurde, oder indem Sie warten, bis der Vorgang abgeschlossen ist:

import { DefaultAzureCredential } from "@azure/identity";
import { CertificateClient } from "@azure/keyvault-certificates";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new CertificateClient(url, credential);

const certificateName = "MyCertificateName";
const certificatePolicy = {
  issuerName: "Self",
  subject: "cn=MyCert",
};

const poller = await client.beginCreateCertificate(certificateName, certificatePolicy);

// You can use the pending certificate immediately:
const pendingCertificate = poller.getResult();

// Or you can wait until the certificate finishes being signed:
const keyVaultCertificate = await poller.pollUntilDone();
console.log(keyVaultCertificate);

Eine weitere Möglichkeit, zu warten, bis das Zertifikat signiert ist, besteht darin, einzelne Aufrufe wie folgt zu erledigen:

import { DefaultAzureCredential } from "@azure/identity";
import { CertificateClient } from "@azure/keyvault-certificates";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new CertificateClient(url, credential);

const certificateName = "MyCertificateName";
const certificatePolicy = {
  issuerName: "Self",
  subject: "cn=MyCert",
};

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

const poller = await client.beginCreateCertificate(certificateName, certificatePolicy);

while (!poller.isDone()) {
  await poller.poll();
  await delay(5000);
}

console.log(`The certificate ${certificateName} is fully created`);

Ein Key Vault-Zertifikat erhalten

Die einfachste Möglichkeit zum Lesen von Zertifikaten aus dem Tresor besteht darin, ein Zertifikat anhand des Namens abzurufen. getCertificate ruft die neueste Version des Zertifikats zusammen mit der Zertifikatrichtlinie ab. Sie können optional eine andere Version des Zertifikats abrufen, indem Sie getCertificateVersion aufrufen, wenn Sie die Version angeben. getCertificateVersion gibt die Richtlinie des Zertifikats nicht zurück.

import { DefaultAzureCredential } from "@azure/identity";
import { CertificateClient } from "@azure/keyvault-certificates";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new CertificateClient(url, credential);

const certificateName = "MyCertificateName";

const latestCertificate = await client.getCertificate(certificateName);
console.log(`Latest version of the certificate ${certificateName}: `, latestCertificate);
const specificCertificate = await client.getCertificateVersion(
  certificateName,
  latestCertificate.properties.version,
);
console.log(
  `The certificate ${certificateName} at the version ${latestCertificate.properties.version}: `,
  specificCertificate,
);

Abrufen der vollständigen Informationen eines Zertifikats

Das Design von Azure Key Vault unterscheidet scharf zwischen Keys, Secrets und Certificates. Die Zertifikatsfunktionen des Key Vault-Dienstes wurden mit den Funktionen Schlüssel und Geheimnisse entwickelt. Lassen Sie uns die Zusammensetzung eines Key Vault-Zertifikats bewerten:

Wenn ein Key Vault-Zertifikat erstellt wird, werden auch ein adressierbarer Schlüssel und ein geheimes Geheimnis mit demselben Namen erstellt. Der Key Vault-Schlüssel ermöglicht Schlüsseloperationen und das Key Vault-Geheimnis ermöglicht die Abrufung des Zertifikatswerts als Geheimnis. Ein Key Vault-Zertifikat enthält außerdem öffentliche x509-Zertifikatsmetadaten. Quelle: Zusammensetzung eines Zertifikats.

Da der private Schlüssel in einem Key Vault Secret mit dem öffentlichen Zertifikat gespeichert ist, können wir ihn mit dem Key Vault Secrets-Client abrufen.

import { DefaultAzureCredential } from "@azure/identity";
import { SecretClient } from "@azure/keyvault-secrets";
import { writeFileSync } from "node:fs";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const keyVaultUrl = `https://${vaultName}.vault.azure.net`;

const secretClient = new SecretClient(keyVaultUrl, credential);

const certificateName = "MyCertificateName";

// Assuming you've already created a Key Vault certificate,
// and that certificateName contains the name of your certificate
const certificateSecret = await secretClient.getSecret(certificateName);

// Here we can find both the private key and the public certificate, in PKCS 12 format:
const PKCS12Certificate = certificateSecret.value!;

// You can write this into a file:
writeFileSync("myCertificate.p12", PKCS12Certificate);

Beachten Sie, dass der Inhaltstyp der Zertifikate standardmäßig PKCS 12 ist. Indem Sie den Inhaltstyp Ihres Zertifikats angeben, können Sie es im PEM-Format abrufen. Bevor Sie zeigen, wie PEM-Zertifikate erstellt werden, erfahren Sie zunächst, wie Sie zuerst einen geheimen PEM-Schlüssel aus einem PKCS 12-Zertifikat abrufen.

Mit opensslkönnen Sie das öffentliche Zertifikat im PEM-Format mit dem folgenden Befehl abrufen:

openssl pkcs12 -in myCertificate.p12 -out myCertificate.crt.pem -clcerts -nokeys

Sie können auch openssl verwenden, um den privaten Schlüssel wie folgt abzurufen:

openssl pkcs12 -in myCertificate.p12 -out myCertificate.key.pem -nocerts -nodes

Beachten Sie, dass sie in beiden Fällen von openssl aufgefordert werden, das Zum Erstellen des Zertifikats verwendete Kennwort einzugeben. Der beispielcode, den wir bisher verwendet haben, hat kein Kennwort angegeben, sodass Sie -passin 'pass:' am Ende jedes Befehls anfügen können.

Zertifikate im PEM-Format

Wenn Sie mit Zertifikaten im PEM-Format arbeiten möchten, können Sie Azure Key Vault Service angeben, Ihre Zertifikate im PEM-Format zu erstellen und zu verwalten, indem Sie die Eigenschaft contentType im Moment der Erstellung der Zertifikate bereitstellen.

Das folgende Beispiel zeigt, wie man die öffentlichen und privaten Teile eines PEM-formatierten Zertifikats mit den Key Vault-Clients für Zertifikate und Geheimnisse erstellt und abruft:

import { DefaultAzureCredential } from "@azure/identity";
import { CertificateClient } from "@azure/keyvault-certificates";
import { SecretClient } from "@azure/keyvault-secrets";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const keyVaultUrl = `https://${vaultName}.vault.azure.net`;

const client = new CertificateClient(keyVaultUrl, credential);
const secretClient = new SecretClient(keyVaultUrl, credential);
// Creating the certificate
const certificateName = "MyCertificate";
const createPoller = await client.beginCreateCertificate(certificateName, {
  issuerName: "Self",
  subject: "cn=MyCert",
  contentType: "application/x-pem-file", // Here you specify you want to work with PEM certificates.
});
await createPoller.pollUntilDone();

// Getting the PEM formatted private key and public certificate:
const certificateSecret = await secretClient.getSecret(certificateName);
const PEMPair = certificateSecret.value!;

console.log(PEMPair);

Denken Sie daran, dass sich Ihr öffentliches Zertifikat im gleichen Blob von Inhalten wie Ihr privater Schlüssel befinden wird. Sie können die PEM-Header verwenden, um sie entsprechend zu extrahieren.

Alle Zertifikate auflisten

listPropertiesOfCertificates listet alle Zertifikate im Key Vault auf.

import { DefaultAzureCredential } from "@azure/identity";
import { CertificateClient } from "@azure/keyvault-certificates";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const keyVaultUrl = `https://${vaultName}.vault.azure.net`;

const client = new CertificateClient(keyVaultUrl, credential);

const certificateName = "MyCertificate";

for await (const certificateProperties of client.listPropertiesOfCertificates()) {
  console.log("Certificate properties: ", certificateProperties);
}
for await (const deletedCertificate of client.listDeletedCertificates()) {
  console.log("Deleted certificate: ", deletedCertificate);
}
for await (const certificateProperties of client.listPropertiesOfCertificateVersions(
  certificateName,
)) {
  console.log("Certificate properties: ", certificateProperties);
}

Aktualisieren eines Zertifikats

Die Zertifikatattribute können wie folgt auf eine vorhandene Zertifikatversion mit updateCertificateaktualisiert werden:

import { DefaultAzureCredential } from "@azure/identity";
import { CertificateClient } from "@azure/keyvault-certificates";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const keyVaultUrl = `https://${vaultName}.vault.azure.net`;

const client = new CertificateClient(keyVaultUrl, credential);

const certificateName = "MyCertificate";

const result = await client.getCertificate(certificateName);
await client.updateCertificateProperties(certificateName, result.properties.version, {
  enabled: false,
  tags: {
    myCustomTag: "myCustomTagsValue",
  },
});

Die Richtlinie des Zertifikats kann auch einzeln mit updateCertificatePolicyaktualisiert werden, wie folgt:

import { DefaultAzureCredential } from "@azure/identity";
import { CertificateClient } from "@azure/keyvault-certificates";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const keyVaultUrl = `https://${vaultName}.vault.azure.net`;

const client = new CertificateClient(keyVaultUrl, credential);

const certificateName = "MyCertificate";

const result = client.getCertificate(certificateName);
// Note: Sending `Self` as the `issuerName` of the certificate's policy will create a self-signed certificate.
await client.updateCertificatePolicy(certificateName, {
  issuerName: "Self",
  subject: "cn=MyCert",
});

Löschen eines Zertifikats

Die beginDeleteCertificate Methode legt ein Zertifikat für das Löschen fest. Dieser Vorgang erfolgt im Hintergrund, sobald die erforderlichen Ressourcen verfügbar sind.

Wenn soft-delete für die Key Vault aktiviert ist, kennzeichnet diese Operation das Zertifikat nur als deleted Zertifikat. Ein gelöschtes Zertifikat kann nicht aktualisiert werden. Sie können nur gelesen, wiederhergestellt oder gelöscht werden.

import { DefaultAzureCredential } from "@azure/identity";
import { CertificateClient } from "@azure/keyvault-certificates";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const keyVaultUrl = `https://${vaultName}.vault.azure.net`;

const client = new CertificateClient(keyVaultUrl, credential);

const certificateName = "MyCertificate";

const poller = await client.beginDeleteCertificate(certificateName);

// You can use the deleted certificate immediately:
const deletedCertificate = poller.getResult();

// The certificate is being deleted. Only wait for it if you want to restore it or purge it.
await poller.pollUntilDone();

// You can also get the deleted certificate this way:
await client.getDeletedCertificate(certificateName);

// Deleted certificates can also be recovered or purged.

// recoverDeletedCertificate returns a poller, just like beginDeleteCertificate.
// const recoverPoller = await client.beginRecoverDeletedCertificate(certificateName);
// await recoverPoller.pollUntilDone();

// If a certificate is done and the Key Vault has soft-delete enabled, the certificate can be purged with:
await client.purgeDeletedCertificate(certificateName);

Da das Löschen eines Zertifikats nicht sofort erfolgt, wird einige Zeit benötigt, nachdem die beginDeleteCertificate Methode aufgerufen wird, bevor das gelöschte Zertifikat gelesen, wiederhergestellt oder gelöscht werden kann.

Durchlaufen von Zertifikatlisten

Mit dem CertificateClient können Sie alle Zertifikate in einem Zertifikattresor sowie über alle gelöschten Zertifikate und die Versionen eines bestimmten Zertifikats abrufen und durchlaufen. Die folgenden API-Methoden sind verfügbar:

  • listPropertiesOfCertificates listet alle Nicht gelöschten Zertifikate anhand ihrer Namen nur auf deren neuesten Versionen auf.
  • listDeletedCertificates listet alle Gelöschten Zertifikate nur nach ihren Namen auf.
  • listPropertiesOfCertificateVersions listet alle Versionen eines Zertifikats basierend auf einem Zertifikatnamen auf.

Dies kann wie folgt verwendet werden:

import { DefaultAzureCredential } from "@azure/identity";
import { CertificateClient } from "@azure/keyvault-certificates";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const keyVaultUrl = `https://${vaultName}.vault.azure.net`;

const client = new CertificateClient(keyVaultUrl, credential);

const certificateName = "MyCertificate";

for await (const certificateProperties of client.listPropertiesOfCertificates()) {
  console.log("Certificate properties: ", certificateProperties);
}
for await (const deletedCertificate of client.listDeletedCertificates()) {
  console.log("Deleted certificate: ", deletedCertificate);
}
for await (const certificateProperties of client.listPropertiesOfCertificateVersions(
  certificateName,
)) {
  console.log("Certificate properties: ", certificateProperties);
}

Alle diese Methoden geben alle verfügbaren Ergebnisse gleichzeitig zurück. Um sie nach Seiten abzurufen, fügen Sie .byPage() direkt nach dem Aufrufen der API-Methode hinzu, die Sie verwenden möchten, wie folgt:

import { DefaultAzureCredential } from "@azure/identity";
import { CertificateClient } from "@azure/keyvault-certificates";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const keyVaultUrl = `https://${vaultName}.vault.azure.net`;

const client = new CertificateClient(keyVaultUrl, credential);

const certificateName = "MyCertificate";

for await (const page of client.listPropertiesOfCertificates().byPage()) {
  for (const certificateProperties of page) {
    console.log("Certificate properties: ", certificateProperties);
  }
}
for await (const page of client.listDeletedCertificates().byPage()) {
  for (const deletedCertificate of page) {
    console.log("Deleted certificate: ", deletedCertificate);
  }
}
for await (const page of client.listPropertiesOfCertificateVersions(certificateName).byPage()) {
  for (const certificateProperties of page) {
    console.log("Properties of certificate: ", certificateProperties);
  }
}

Fehlerbehebung

Das Aktivieren der Protokollierung kann hilfreiche Informationen zu Fehlern aufdecken. Um ein Protokoll von HTTP-Anforderungen und -Antworten anzuzeigen, legen Sie die AZURE_LOG_LEVEL Umgebungsvariable auf infofest. Alternativ kann die Protokollierung zur Laufzeit durch Aufrufen von setLogLevel im @azure/loggeraktiviert werden:

import { setLogLevel } from "@azure/logger";

setLogLevel("info");

Siehe unseren Fehlerbehebungsleitfaden für Details zur Diagnose verschiedener Fehlerszenarien.

Nächste Schritte

Weitere Codebeispiele finden Sie über die folgenden Links:

Beitragend

Wenn Sie zu dieser Bibliothek beitragen möchten, lesen Sie bitte den beitragenden Leitfaden, um mehr darüber zu erfahren, wie man den Code erstellt und testet.

  • Last updated on