Ressourcen

Warum wir diesen Ansatz wählen

Wir mussten eine komplette EC2-Instanz von AWS zu GCP migrieren, einschließlich aller Daten und der auf der AWS EC2-Instanz gehosteten Anwendung. Dazu wählten wir die Option „Migrate to Virtual Machines“ unter dem Compute Engine-Dienst in GCP. Es gibt andere Optionen, die das AMI der EC2-Instanz migrieren, doch die Übertragung zusätzlicher Daten stellt dabei eine erhebliche Herausforderung dar. 

Die Migration der EC2-Instanz wurde mithilfe der unten beschriebenen Methode erfolgreich durchgeführt, was den gesamten GCP-Migrationsprozess optimierte.

Eine detaillierte Schritt-für-Schritt-Erklärung finden Sie unten.

Voraussetzungen in der AWS-Konsole

Wir haben in der AWS-Konsole einen Benutzer erstellt, einen Zugriffsschlüssel und einen geheimen Schlüssel für den Benutzer generiert und diesem Administratorberechtigungen zugewiesen. Diese Schlüssel wurden verwendet, um eine EC2-Instanz zu einer GCP-VM-Instanz zu migrieren.

Unten sind unsere EC2-Instanzen in der AWS-Konsole aufgeführt. Wir migrieren diese Instanzen in die GCP-Konsole.

Auf dieser EC2-Instanz haben wir eine statische Webanwendung, wie im Screenshot unten gezeigt.

‍SCHRITT: 01

Öffnen Sie die GCP-Konsole, navigieren Sie zu Compute Engine und rufen Sie den Dienst „Migrate to Virtual Machines“ auf.

Migrate to Virtual Machines

Mithilfe der „Virtual Machines“-Option unter dem Compute Engine-Dienst haben wir die EC2-Instanz erfolgreich migriert.

SCHRITT: 02

Fügen Sie die Quelle hinzu, von der wir die EC2-Instanz migrieren müssen, wie AWS oder Azure. Hier migrieren wir eine EC2-Instanz von AWS zu GCP.

Wählen Sie eine AWS-Quelle.

Um die AWS-Quelle zu erstellen, geben Sie bitte die erforderlichen Details an, wie im Screenshot unten gezeigt.

Verifizieren Sie alle Details und erstellen Sie die AWS-Quelle. Sobald eine AWS-Quelle erstellt wurde, werden alle AWS EC2-Instanzen dieser Quelle in unserer GCP-Konsole sichtbar sein, wie im folgenden Screenshot gezeigt.

Wählen Sie aus der obigen Liste die Instanz aus, die zu einer GCP VM-Instanz migriert werden soll.

‍SCHRITT: 03

Ich habe eine AWS EC2-Instanz ausgewählt und möchte sie zu Google Cloud migrieren, indem ich auf „VM-Migration hinzufügen“ klicke und bestätige, wie unten gezeigt.

Navigieren Sie zur VM-Migration und starten Sie die Replikation.

Die Migration aller Daten von AWS zu GCP, wie im Screenshot gezeigt, dauert einige Zeit.

SCHRITT: 04

Geben Sie die Konfigurationsdetails für den Start der VM-Instanz in GCP an, einschließlich Maschinentyp, VPC, Instanzname, öffentlichen und privaten IPs, Festplattentypen und Dienstkonto. Weisen Sie der neu gestarteten VM-Instanz außerdem die entsprechende Lizenz zu, indem Sie auf „Zieldetails bearbeiten“ klicken und die erforderlichen Informationen angeben.

Füllen Sie die Details aus, wie in den Screenshots gezeigt:

SCHRITT: 05

Ich habe ein neues Dienstkonto in meinem GCP-Testprojekt mit der „Dienstkontonutzer“ Rolle erstellt. Diese Rolle ist unerlässlich für den Start einer GCP VM-Instanz, daher müssen wir dieses Dienstkonto in den Quell-Zieldetails angeben, wie in den obigen Screenshots gezeigt.

Überprüfen Sie abschließend alle Details und klicken Sie dann auf „Speichern“. Die Zieldetails werden erfolgreich aktualisiert.

SCHRITT: 06

Bevor wir zum endgültigen Cut-off-Zustand übergehen, werden wir eine Test-VM-Instanz mithilfe des Test-Klons starten und die Einrichtung bestätigen. Dieser Schritt stellt sicher, dass alle Konfigurationen korrekt sind und alle Daten erfolgreich migriert wurden, bevor zum endgültigen Cut-off-Zustand übergegangen wird.

Wo der Test-Klon stattfindet – unter Verwendung der replizierten Daten und Zieldetails – um eine erste Test-VM-Instanz in der GCP-Konsole zu starten.

Testprozess:

‍

SCHRITT: 07

Während der letzten Umstellungsphase des Migrationsprozesses wird nur die ursprüngliche VM-Instanz in der GCP-Konsole gestartet, die exakt der EC2-Instanz in der AWS-Konsole entspricht

Nach der Umstellungsphase haben wir erfolgreich eine VM-Instanz gestartet, wie in den folgenden Screenshots gezeigt.

SCHRITT: 08

Nachdem wir uns erfolgreich via RDP mit der neu gestarteten VM-Instanz in der GCP-Konsole verbunden hatten, haben wir überprüft, dass alle von der EC2-Instanz in der AWS-Konsole migrierten Daten in der GCP-VM-Instanz vorhanden waren.

Als Referenz finden Sie den Screenshot unten.

SCHRITT: 09

Wir haben außerdem überprüft, dass unsere Anwendung, eine statische Webseite, die auf einer EC2-Instanz in der AWS-Konsole gehostet wird, auf der GCP-VM-Maschine wie erwartet funktioniert.

Daher haben wir erfolgreich eine AWS EC2-Instanz von der AWS Cloud zur GCP Cloud migriert.

E-Mail-Spoofing ist eine Technik, bei der der Angreifer die Absenderadresse so fälscht, dass der Empfänger glaubt, die E-Mail stamme von einer vertrauenswürdigen Partei. Dies könnte ein Kollege im Büro, ein Unternehmen oder sogar ein Finanzinstitut sein. In diesem Szenario sendet ein Angreifer E-Mail-Header so, dass der Empfänger davon ausgeht, die E-Mail stamme von einer bestimmten Person. Dadurch steigt die Wahrscheinlichkeit, dass Personen auf schädliche Links klicken, gefährliche Anhänge herunterladen oder sensible Informationen preisgeben.

Den meisten aktuellen E-Mail-Systemen fehlt eine gute Funktion zur Identifizierung gefälschter Absenderadressen. Dies erklärt, warum die meisten Phishing-, Spear-Phishing- und Business-E-Mail-Compromise-Angriffe auf einer solchen Strategie basieren.

Zum Beispiel könnten Sie eine E-Mail erhalten, bei der Sie sowohl im „An“- als auch im „Von“-Feld stehen. Das bedeutet nicht, dass jemand Ihr E-Mail-Konto gehackt hat. Stattdessen würde der Angreifer vorgeben, Sie oder eine andere vertrauenswürdige Person zu sein, damit Sie die E-Mail öffnen und möglicherweise auf schädliche Links klicken oder sensible Informationen preisgeben.

Wieman eine gefälschte E-Mail erkennt?

Der Ordner „Gesendet“ enthält keine E-Mail - Wenn Sie sich selbst eine E-Mail senden, befindet sie sich immer in Ihrem Ordner „Gesendet“. Da Spammer Ihre Adresse gefälscht haben, würden Sie sie dort nie sehen, weil sie von nirgendwo gesendet wurde, aber es würde so aussehen, als käme sie von Ihrem Konto.

‍HINWEIS: Wenn Sie eine E-Mail an sich selbst verfassen und diese aus Ihrem Ordner „Gesendet“ löschen, wird die E-Mail auch nicht mehr in Ihrem Posteingang angezeigt.

Original-E-Mail prüfen - Die meisten E-Mail-Systeme zeigen Ihnen die „Original“- oder „Rohversion“ einer E-Mail an. Diese enthält alle technischen Details zum Versand der E-Mail. Achten Sie auf mögliche Anzeichen wie verdächtige „From“-, „Reply-To“-, „Return-Path“- oder „Received“-Felder, die nicht korrekt aussehen – dies könnte ein Hinweis auf eine gefälschte E-Mail sein.

Grammatik- und Rechtschreibfehler - Achten Sie immer auf Homoglyphen (Beispiel: Ankercloud als Amk3rc10ud) und Grammatikfehler, die ein seriöser Absender niemals machen würde.

Präventivmaßnahmen: zum Schutz Ihrer Person und Ihres Unternehmens

• Implementieren Sie die E-Mail-Sicherheitsprotokolle SPF, DKIM und DMARC als Schutzschicht gegen Spoofing, die dabei hilft, zu überprüfen, ob eine E-Mail tatsächlich von der Person gesendet wurde, von der sie angeblich stammt. Andernfalls wird die E-Mail sofort in den Spam-Ordner verschoben oder gelöscht. 
• Spamfilter verwenden – Die meisten E-Mail-Dienste verfügen in der Regel über Spamfilter. Diese können verdächtig aussehende E-Mails filtern, noch bevor sie Ihren Posteingang erreichen. Gehen Sie zur Sicherheit davon aus, dass Ihr Spamfilter aktiv ist.
• Seien Sie vorsichtig – Öffnen Sie keine unerwünschten E-Mails, insbesondere wenn sie verdächtig erscheinen oder nach vertraulichen Informationen fragen.

‍Was tun, wenn Sie Opfer eines Spoofing-Angriffs werden?

• Geraten Sie nicht in Panik und trennen Sie das Gerät sofort vom Internet, um sicherzustellen, dass keine weiteren Schäden durch heruntergeladene Schadprogramme entstehen.
• Informieren Sie das IT-Team über den Vorfall, damit diese beurteilen können, ob sensible Informationen gefährdet wurden, und alle notwendigen Vorkehrungen treffen können, um Sicherheitsmaßnahmen für Ihr Konto zu gewährleisten. 
• Ändern Sie Ihre Passwörter: Falls Sie eine Infektion vermuten, ändern Sie alle Passwörter sofort von einem anderen Gerät aus und implementieren/erzwingen Sie die Zwei-Faktor-Authentifizierung (2FA) für eine zusätzliche Sicherheitsebene. 
• Behalten Sie Ihr E-Mail-Konto und andere Online-Konten im Auge auf verdächtige Aktivitäten wie unautorisierte Anmeldeversuche oder verdächtige Aktivitäten über Ihre Konten.

Fazit 

E-Mail-Spoofing ist sehr schwer zu verhindern, aber definitiv schwer zu erkennen; wenn Sie jedoch aufmerksam sind und einige grundlegende Vorsichtsmaßnahmen beachten, sollten Sie niemals auf einen solchen Betrug hereinfallen. Überprüfen Sie daher immer verdächtige E-Mails und wenden Sie sich im Zweifelsfall an Ihr IT-/Sicherheitsteam. Zögern Sie nicht, um Hilfe zu bitten.

Im Juni 2023 hat die Europäische Union mit der Einführung des KI-Gesetzes einen bedeutenden Schritt bei der Regulierung künstlicher Intelligenz unternommen. Diese wegweisende Gesetzgebung zielt darauf ab, einen rechtlichen Rahmen für die Entwicklung und den Einsatz von KI in der gesamten EU zu schaffen, um sicherzustellen, dass KI-Technologien verantwortungsvoll und ethisch eingesetzt werden. Für Unternehmen, die KI nutzen, ist das Verständnis und die Einhaltung des KI-Gesetzes entscheidend, um Strafen zu vermeiden und das Vertrauen der Verbraucher zu erhalten. Hier kommt Ankercloud ins Spiel und bietet Lösungen an, um Unternehmen bei der Bewältigung der Komplexität des neuen Gesetzes zu unterstützen.

Das KI-Gesetz verstehen

Das KI-Gesetz klassifiziert KI-Systeme nach ihrem potenziellen Risiko in drei Kategorien:

1. Unannehmbares Risiko: KI-Anwendungen, die als Bedrohung für Sicherheit, Lebensgrundlagen und Rechte angesehen werden, sind verboten. Dazu gehören Systeme zur sozialen Bewertung durch Regierungen und zur biometrischen Echtzeit-Identifizierung im öffentlichen Raum.
2. Hohes Risiko: KI-Systeme, die kritische Bereiche wie Gesundheitswesen, Verkehr und Beschäftigung betreffen, müssen strenge Anforderungen erfüllen. Dazu gehören ein robustes Risikomanagement, hochwertige Daten, menschliche Aufsicht und Transparenz.
3. Begrenztes Risiko: Anwendungen mit minimalem Risiko, wie Chatbots, müssen Transparenz gewährleisten und Nutzer darüber informieren, dass sie mit einer KI interagieren.

Für Unternehmen, insbesondere solche, die in Hochrisikokategorien tätig sind, schreibt das KI-Gesetz einen umfassenden Ansatz für Risikomanagement, Daten-Governance und Compliance-Dokumentation vor.

Herausforderungen für Unternehmen

Die Einführung des KI-Gesetzes stellt Unternehmen vor mehrere Herausforderungen:

• Compliance-Kosten: Die Einhaltung der strengen Anforderungen des KI-Gesetzes kann erhebliche Kosten verursachen, insbesondere für KMU.
• Technisches Fachwissen: Sicherzustellen, dass KI-Systeme den gesetzlichen Standards entsprechen, erfordert spezialisiertes Wissen in der KI-Entwicklung und Daten-Governance.
• Dokumentation und Transparenz: Unternehmen müssen detaillierte Aufzeichnungen über das Design, die Tests und die Bereitstellungsprozesse ihrer KI-Systeme führen.

Wie Ankercloud helfen kann

Ankercloud bietet eine Reihe von Dienstleistungen an, die Unternehmen dabei unterstützen, das neue KI-Gesetz nahtlos und effizient einzuhalten. So kann Ankercloud helfen:

1. Risikobewertung und -management:
   • Umfassende Risikoanalyse: Ankercloud unterstützt bei der Bewertung der mit KI-Systemen verbundenen Risiken und hilft Unternehmen, potenzielle Probleme frühzeitig im Entwicklungsprozess gemäß den Best Practices der Branche zu erkennen.
   • Strategien zur Risikominderung: Durch detaillierte Analysen und fachkundige Beratung hilft Ankercloud bei der Implementierung robuster Strategien zur Risikominderung und gewährleistet so die Einhaltung der Hochrisiko-Anforderungen des KI-Gesetzes.
2. Data Governance:
   • Qualitätsdatenmanagement: Der Ansatz von Ankercloud für Data Governance stellt sicher, dass KI-Systeme mit hochwertigen, unvoreingenommenen Daten trainiert werden und die Standards des KI-Gesetzes erfüllen.
     1. ISO/IEC 25024: Dieser internationale Standard beschreibt Kriterien zur Messung der Datenqualität wie Genauigkeit, Vollständigkeit, Konsistenz und Aktualität. Die Plattform von Ankercloud hilft Unternehmen, diese Metriken zu bewerten, um sicherzustellen, dass ihre Daten den regulatorischen Erwartungen entsprechen.
     2. Fairness und Voreingenommenheitsminderung: Gemäß dem KI-Gesetz müssen Daten, die für Hochrisiko-KI-Systeme verwendet werden, frei von Voreingenommenheit sein. Ankercloud integriert KI-Fairness-Tools, die voreingenommene Datensätze erkennen und korrigieren und so die Einhaltung der EU-Anforderungen an Fairness, Inklusivität und Nichtdiskriminierung gewährleisten.
     3. Nachvollziehbarkeit und Transparenz: Ankercloud ermöglicht es Unternehmen, die Herkunft ihrer Daten zu verfolgen und zu dokumentieren, um die Transparenzanforderungen des KI-Gesetzes zu erfüllen. Diese Funktion trägt dazu bei, Rechenschaftspflicht und Überprüfbarkeit während des gesamten KI-Lebenszyklus zu gewährleisten.
   • Datensicherheit und Datenschutz: Es ist entscheidend, dass personenbezogene Daten geschützt und die Privatsphäre gewahrt bleiben. Ankercloud hilft bei der Implementierung von Sicherheitsmaßnahmen und Datenschutzprotokollen, die dem KI-Gesetz entsprechen.
     1. ISO/IEC 27001: Dieser Standard definiert die Anforderungen an ein umfassendes Informationssicherheits-Managementsystem (ISMS). Ankercloud unterstützt Unternehmen bei der Implementierung und Verwaltung von Informationssicherheitsstrategien, um den Schutz sensibler Daten zu gewährleisten.
     2. DSGVO (Datenschutz-Grundverordnung): Die DSGVO ist die zentrale Verordnung in der EU zum Schutz personenbezogener Daten. Ankercloud unterstützt Unternehmen bei der Einhaltung der DSGVO-Anforderungen, einschließlich Datenminimierung, Einholung der Einwilligung zur Datennutzung und der Gewährleistung der Rechte der betroffenen Personen.
     3. ISO/IEC 27701: Diese Erweiterung der ISO 27001 bietet Richtlinien für den Datenschutz und unterstützt bei der Implementierung eines Datenschutz-Informationsmanagementsystems (PIMS). Ankercloud integriert diesen Standard, um Unternehmen bei der Einhaltung von Datenschutzvorschriften zu unterstützen.
     4. Verschlüsselung und Zugriffskontrollen: Ankercloud implementiert Technologien wie End-to-End-Verschlüsselung und Multi-Faktor-Authentifizierung, um den Schutz von Daten während der Übertragung und Speicherung zu gewährleisten. Dies hilft Unternehmen, die Sicherheitsanforderungen des KI-Gesetzes zu erfüllen. Die umfassenden Sicherheits- und Datenschutzlösungen von Ankercloud helfen Unternehmen, das Risiko von Datenlecks zu minimieren und die Einhaltung relevanter Sicherheitsstandards zu gewährleisten, was für den Einsatz von KI im Einklang mit dem KI-Gesetz entscheidend ist.

3. Transparenz und Dokumentation:
   • Dokumentationsunterstützung: Ankercloud unterstützt bei der Erstellung und Pflege umfassender Dokumentation der Entwicklung und des Einsatzes von KI-Systemen, was für Audits und behördliche Überprüfungen unerlässlich ist.
4. Menschliche Aufsicht:
   • Human-in-the-Loop-Lösungen: Ankercloud hilft bei der Integration von Mechanismen zur menschlichen Aufsicht in KI-Systeme, um sicherzustellen, dass kritische Entscheidungen von Menschen überprüft werden, wie es das KI-Gesetz vorschreibt.
5. Schulung und Support:
   • Kontinuierliche Unterstützung: Mit kontinuierlichem Support und 24/7-Account-Management durch ein engagiertes Managed Services Team stellt Ankercloud kontinuierlich sicher, dass Unternehmen auf lange Sicht mit sich entwickelnden Vorschriften und Industriestandards konform bleiben.

Fazit

Das KI-Gesetz der EU markiert einen entscheidenden Moment in der Regulierung künstlicher Intelligenz und unterstreicht die Bedeutung eines ethischen und verantwortungsvollen Einsatzes von KI. Für Unternehmen mag die Navigation in dieser neuen Rechtslandschaft entmutigend erscheinen. Doch mit den umfassenden Lösungen von Ankercloud können Unternehmen die Compliance souverän managen, Risiken mindern und das volle Potenzial der KI im Rahmen der gesetzlichen Vorgaben ausschöpfen. Eine Partnerschaft mit Ankercloud stellt sicher, dass Ihr Unternehmen nicht nur die regulatorischen Anforderungen erfüllt, sondern auch einen Maßstab für verantwortungsvolle KI-Innovationen setzt.

A newly identified vulnerability called "ALBeast" can cause a significant risk for AWS Application Load Balancer (ALB) using the load balancer authentication. This vulnerability was found by Miggo Research, meaning it is a severe problem that can lead to unauthorized access, data exfiltration, data breaches, and insider threats. Understanding it and mitigating this vulnerability is essential to organizations that are relying on the AWS Application Load Balancer to secure their applications.

Understanding ALBeast: What You Need to Know

ALBeast is a configuration-based vulnerability, the base of this vulnerability is "how AWS ALB handles the user authentication". ALB is a load balancer that operates on the OSI model's Layer 7. Its purpose is to handle the traffic by distributing the incoming application traffic across multiple targets like EC2 instances, containers, or IP addresses. On the one hand, the ALB improves reliability, fault tolerance, and scalability. And, the misconfiguration in ALB's authentication process can lead to a security breach where applications are exposed to the risk of being compromised.

The ALBeast vulnerability is critical because, with the help of this vulnerability, the attackers can bypass the critical security controls and lead to unauthorized access, by which attackers can access the applications without authentication. The Miggo research has identified over 15,000 potentially vulnerable applications out of the 371,000 ALBs analyzed, these potentially vulnerable applications do not contain the proper signer validation which is a key contributor to ALB-based authentication.

How Does ALBeast Vulnerability Work?

The ALBeast vulnerability exploits the weaknesses in how the applications validate the tokens provided by ALB. This vulnerability is raised because of two main issues which are:

1. Missing Signer Validation: Many of the applications fail to verify the authenticity of the token signer, which means that the attacker can forge a token, manipulate it, impersonate it as a legitimate token, and present it to the application. Because of this misconfiguration, the application does not validate the signer's identity, accepts the token then grants the attacker unauthorized access.
2. Misconfigured Security Groups: ALBeast vulnerability also takes advantage of misconfigurations in configured security groups that do not restrict traffic to trusted ALB instances. If an application accepts traffic from any source rather than limiting it to a specific ALB, an attacker can exploit this to bypass security controls.

Exploitation Scenario: How Attackers Exploit

• Setting Up a Malicious ALB: The attacker creates the malicious Application Load Balancer (ALB) which has similar configurations to the victim's setup.
• Forging a Token: The attacker forges a token and changes the information inside it, especially the part that says who issued it, to match what the victim’s application considers legitimate.
• Altering the Configurations: The attacker changes the configurations on the Malicious ALB so that AWS signs the token in a way that makes it look legitimate to the victim’s system.
• Bypassing Defenses: The attacker then uses this fake token to trick the victim’s application into bypassing security checks and gaining unauthorized access.

‍

Best Practices to Mitigate ALBeast

1. Verify Token Signer: Ensure that the applications are validating the signer of a JWT token provided with ALB to verify that the signer field from the JWT header matches the Amazon Resource Name (ARN) of the ALB signing the token.
2. Restrict Traffic to Trusted ALBs: Configure your security groups to accept traffic only from trusted ALB instances. This can be achieved by referencing the ALB’s security group in the inbound rules for your target security group.
3. Deploy Targets in Private Subnets: To prevent direct access from the public internet, deploy your ALB targets in private subnets without public IP addresses or Elastic IP addresses.
4. Review and Update Configurations: Regularly review your application’s configurations to ensure they adhere to the latest AWS documentation. AWS has updated its authentication feature documentation to include new code for validating the signer, making it crucial for users to implement these changes.

Conclusion

The ALBeast vulnerability is a wake-up call for all organizations about how misconfigurations can lead to complex vulnerabilities in cloud-based applications. AWS has provided reliable tools for security management, though the responsibility to properly set up these tools is on the user. Organizations can immensely reduce the threat of unauthorized access to their applications based on the ALBeast issue by following the recommended mitigation strategies. These security risks accompany the continuous changes in cloud environments. The organizations should keep themselves up to date, ensure that they regularly update the configurations, and prepare to defend against threats like ALBeast.

Einführung

Application Performance Management (APM) ist entscheidend für die Überwachung und Verwaltung der Leistung und Verfügbarkeit von Softwareanwendungen. Pinpoint ist ein Open-Source-APM-Tool, das umfassende Einblicke in die Leistung und Zuverlässigkeit von Anwendungen bietet. Es wurde entwickelt, um große verteilte Systeme zu überwachen und liefert Echtzeit-Leistungsmetriken, Tracing und detaillierte Visualisierungen.

Dieser Leitfaden bietet eine Schritt-für-Schritt-Anleitung zur Implementierung von Pinpoint APM für eine Node.js-Anwendung, einschließlich der Einrichtung des Servers, der Installation von Docker, der Bereitstellung von Pinpoint und dessen Integration in die Node.js-Anwendung.

Über Pinpoint

Pinpoint ist ein leistungsstarkes APM-Tool, das hilft, die Anwendungsleistung zu verstehen und Probleme aufzuspüren. Es unterstützt eine Vielzahl von Technologien und bietet Funktionen wie:

• Echtzeit-Anwendungsüberwachung
• Verteiltes Tracing
• Visualisierung der Anwendungstopologie
• Warnungen und Benachrichtigungen
• Detaillierte Transaktionsanalyse

Server einrichten:

Wir müssen einen neuen Server mit mindestens 2vCPU und 4GB RAM starten.

Docker Engine installieren

sudo apt-get update

sudo apt-get install docker-ce docker-ce-cli containerd.io

Docker Compose installieren

Laden Sie die Docker Compose Binärdatei in das Verzeichnis /usr/local/bin herunter:

sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Ausführungsberechtigungen auf die Binärdatei anwenden

sudo chmod +x /usr/local/bin/docker-compose

Installation überprüfen:

docker --version

docker-compose --version

‍
Pinpoint mit Docker bereitstellen

Das Git-Repository klonen:

git clone https://github.com/pinpoint-apm/pinpoint-docker.git

cd pinpoint-docker

sudo docker-compose pull && docker-compose up -d
‍

HINWEIS:
Sollte die obige docker-compose.yml nicht funktionieren, verwenden Sie bitte die folgende YML-Datei, um Docker zu starten.

version: "3.6"

services:

  pinpoint-hbase:

    build:

      context: ./pinpoint-hbase/

      dockerfile: Dockerfile

      args:

        - PINPOINT_VERSION=${PINPOINT_VERSION}

    container_name: "${PINPOINT_HBASE_NAME}"

    image: "pinpointdocker/pinpoint-hbase:${PINPOINT_VERSION}"

    networks:

      - pinpoint

    environment:

      - AGENTINFO_TTL=${AGENTINFO_TTL}

      - AGENTSTATV2_TTL=${AGENTSTATV2_TTL}

      - APPSTATAGGRE_TTL=${APPSTATAGGRE_TTL}

      - APPINDEX_TTL=${APPINDEX_TTL}

      - AGENTLIFECYCLE_TTL=${AGENTLIFECYCLE_TTL}

      - AGENTEVENT_TTL=${AGENTEVENT_TTL}

      - STRINGMETADATA_TTL=${STRINGMETADATA_TTL}

      - APIMETADATA_TTL=${APIMETADATA_TTL}

      - SQLMETADATA_TTL=${SQLMETADATA_TTL}

      - TRACEV2_TTL=${TRACEV2_TTL}

      - APPTRACEINDEX_TTL=${APPTRACEINDEX_TTL}

      - APPMAPSTATCALLERV2_TTL=${APPMAPSTATCALLERV2_TTL}

      - APPMAPSTATCALLEV2_TTL=${APPMAPSTATCALLEV2_TTL}

      - APPMAPSTATSELFV2_TTL=${APPMAPSTATSELFV2_TTL}

      - HOSTAPPMAPV2_TTL=${HOSTAPPMAPV2_TTL}

    volumes:

      - hbase_data:/home/pinpoint/hbase

      - /home/pinpoint/zookeeper

    expose:

      # API-Port des HBase Masters

      - "60000"

      # Web-UI des HBase Masters

      - "16010"

      # API-Port des Regionservers

      - "60020"

      # Web-UI des HBase Regionservers

      - "16030"

    ports:

      - "60000:60000"

      - "16010:16010"

      - "60020:60020"

      - "16030:16030"

    restart: immer

    depends_on:

      - zoo1

‍

  pinpoint-mysql:

    container_name: pinpoint-mysql

    image: mysql:8.0

    restart: "no"

    hostname: pinpoint-mysql

    entrypoint: > 

      sh -c "

      curl -SL "https://raw.githubusercontent.com/ga-ram/pinpoint/latest/web/src/main/resources/sql/CreateTableStatement-mysql.sql" -o /docker-entrypoint-initdb.d/CreateTableStatement-mysql.sql &&

      curl -SL "https://raw.githubusercontent.com/ga-ram/pinpoint/latest/web/src/main/resources/sql/SpringBatchJobRepositorySchema-mysql.sql" -o /docker-entrypoint-initdb.d/SpringBatchJobRepositorySchema-mysql.sql &&

      sed -i '/^--/d' /docker-entrypoint-initdb.d/CreateTableStatement-mysql.sql &&

      sed -i '/^--/d' /docker-entrypoint-initdb.d/SpringBatchJobRepositorySchema-mysql.sql &&

      docker-entrypoint.sh mysqld

      "

    ports:

      - "3306:3306"

    environment:

      - MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}

      - MYSQL_USER=${MYSQL_USER}

      - MYSQL_PASSWORD=${MYSQL_PASSWORD}

      - MYSQL_DATABASE=${MYSQL_DATABASE}

    volumes:

      - mysql_data:/var/lib/mysql

    networks:

      - pinpoint

‍

  pinpoint-web:

    build:

      context: ./pinpoint-web/

      dockerfile: Dockerfile

      args:

        - PINPOINT_VERSION=${PINPOINT_VERSION}

    container_name: "${PINPOINT_WEB_NAME}"

    image: "pinpointdocker/pinpoint-web:${PINPOINT_VERSION}"

    depends_on:

      - pinpoint-hbase

      - pinpoint-mysql

      - zoo1

      - redis

    restart: always

    expose:

      - "9997"

    ports:

      - "9997:9997"

      - "${WEB_SERVER_PORT:-8080}:8080"

    environment:

      - WEB_SERVER_PORT=${WEB_SERVER_PORT}

      - SPRING_PROFILES_ACTIVE=${SPRING_PROFILES}

      - PINPOINT_ZOOKEEPER_ADDRESS=${PINPOINT_ZOOKEEPER_ADDRESS}

      - CLUSTER_ENABLE=${CLUSTER_ENABLE}

      - ADMIN_PASSWORD=${ADMIN_PASSWORD}

      - CONFIG_SENDUSAGE=${CONFIG_SENDUSAGE}

      - LOGGING_LEVEL_ROOT=${WEB_LOGGING_LEVEL_ROOT}

      - CONFIG_SHOW_APPLICATIONSTAT=${CONFIG_SHOW_APPLICATIONSTAT}

      - JDBC_DRIVERCLASSNAME=${JDBC_DRIVERCLASSNAME}

      - JDBC_URL=${SPRING_DATASOURCE_HIKARI_JDBCURL}

      - JDBC_USERNAME=${SPRING_DATASOURCE_HIKARI_USERNAME}

      - JDBC_PASSWORD=${SPRING_DATASOURCE_HIKARI_PASSWORD}

      - SPRING_DATASOURCE_HIKARI_JDBCURL=${SPRING_DATASOURCE_HIKARI_JDBCURL}

      - SPRING_DATASOURCE_HIKARI_USERNAME=${SPRING_DATASOURCE_HIKARI_USERNAME}

      - SPRING_DATASOURCE_HIKARI_PASSWORD=${SPRING_DATASOURCE_HIKARI_PASSWORD}

      - SPRING_METADATASOURCE_HIKARI_JDBCURL=${SPRING_METADATASOURCE_HIKARI_JDBCURL}

      - SPRING_METADATASOURCE_HIKARI_USERNAME=${SPRING_METADATASOURCE_HIKARI_USERNAME}

      - SPRING_METADATASOURCE_HIKARI_PASSWORD=${SPRING_METADATASOURCE_HIKARI_PASSWORD}

      - SPRING_DATA_REDIS_HOST=${SPRING_DATA_REDIS_HOST}

      - SPRING_DATA_REDIS_PORT=${SPRING_DATA_REDIS_PORT}

      - SPRING_DATA_REDIS_USERNAME=${SPRING_DATA_REDIS_USERNAME}

      - SPRING_DATA_REDIS_PASSWORD=${SPRING_DATA_REDIS_PASSWORD}

    links:

      - "pinpoint-mysql:pinpoint-mysql"

    networks:

      - pinpoint

  pinpoint-collector:

    build:

      context: ./pinpoint-collector/

      dockerfile: Dockerfile

      args:

        - PINPOINT_VERSION=${PINPOINT_VERSION}

    container_name: "${PINPOINT_COLLECTOR_NAME}"

    image: "pinpointdocker/pinpoint-collector:${PINPOINT_VERSION}"

    depends_on:

      - pinpoint-hbase

      - zoo1

      - redis

    restart: always

    expose:

      - "9991"

      - "9992"

      - "9993"

      - "9994"

      - "9995"

      - "9996"

    ports:

      - "${COLLECTOR_RECEIVER_GRPC_AGENT_PORT:-9991}:9991/tcp"

      - "${COLLECTOR_RECEIVER_GRPC_STAT_PORT:-9992}:9992/tcp"

      - "${COLLECTOR_RECEIVER_GRPC_SPAN_PORT:-9993}:9993/tcp"

      - "${COLLECTOR_RECEIVER_BASE_PORT:-9994}:9994"

      - "${COLLECTOR_RECEIVER_STAT_UDP_PORT:-9995}:9995/tcp"

      - "${COLLECTOR_RECEIVER_SPAN_UDP_PORT:-9996}:9996/tcp"

      - "${COLLECTOR_RECEIVER_STAT_UDP_PORT:-9995}:9995/udp"

      - "${COLLECTOR_RECEIVER_SPAN_UDP_PORT:-9996}:9996/udp"

    networks:

      pinpoint:

        ipv4_address: ${COLLECTOR_FIXED_IP}

    environment:

      - SPRING_PROFILES_ACTIVE=${SPRING_PROFILES}

      - PINPOINT_ZOOKEEPER_ADDRESS=${PINPOINT_ZOOKEEPER_ADDRESS}

      - CLUSTER_ENABLE=${CLUSTER_ENABLE}

      - LOGGING_LEVEL_ROOT=${COLLECTOR_LOGGING_LEVEL_ROOT}

      - FLINK_CLUSTER_ENABLE=${FLINK_CLUSTER_ENABLE}

      - FLINK_CLUSTER_ZOOKEEPER_ADDRESS=${FLINK_CLUSTER_ZOOKEEPER_ADDRESS}

      - SPRING_DATA_REDIS_HOST=${SPRING_DATA_REDIS_HOST}

      - SPRING_DATA_REDIS_PORT=${SPRING_DATA_REDIS_PORT}

      - SPRING_DATA_REDIS_USERNAME=${SPRING_DATA_REDIS_USERNAME}

      - SPRING_DATA_REDIS_PASSWORD=${SPRING_DATA_REDIS_PASSWORD}

  pinpoint-quickstart:

    build:

      context: ./pinpoint-quickstart/

      dockerfile: Dockerfile

    container_name: "pinpoint-quickstart"

    image: "pinpointdocker/pinpoint-quickstart"

    ports:

      - "${APP_PORT:-8085}:8080"

    volumes:

      - data-volume:/pinpoint-agent

    environment:

      JAVA_OPTS: "-javaagent:/pinpoint-agent/pinpoint-bootstrap.jar -Dpinpoint.agentId=${AGENT_ID} -Dpinpoint.applicationName=${APP_NAME} -Dpinpoint.profiler.profiles.active=${SPRING_PROFILES}"

    networks:

      - pinpoint

    depends_on:

      - pinpoint-agent

  pinpoint-batch:

    build:

      context: ./pinpoint-batch/

      dockerfile: Dockerfile

      args:

        - PINPOINT_VERSION=${PINPOINT_VERSION}

    container_name: "${PINPOINT_BATCH_NAME}"

    image: "pinpointdocker/pinpoint-batch:${PINPOINT_VERSION}"

    depends_on:

      - pinpoint-hbase

      - pinpoint-mysql

      - zoo1

    restart: always

    environment:

      - BATCH_SERVER_PORT=${BATCH_SERVER_PORT}

      - SPRING_PROFILES_ACTIVE=${SPRING_PROFILES}

      - PINPOINT_ZOOKEEPER_ADDRESS=${PINPOINT_ZOOKEEPER_ADDRESS}

      - CLUSTER_ENABLE=${CLUSTER_ENABLE}

      - ADMIN_PASSWORD=${ADMIN_PASSWORD}

      - CONFIG_SENDUSAGE=${CONFIG_SENDUSAGE}

      - LOGGING_LEVEL_ROOT=${BATCH_LOGGING_LEVEL_ROOT}

      - CONFIG_SHOW_APPLICATIONSTAT=${CONFIG_SHOW_APPLICATIONSTAT}

      - BATCH_FLINK_SERVER=${BATCH_FLINK_SERVER}

      - JDBC_DRIVERCLASSNAME=${JDBC_DRIVERCLASSNAME}

      - JDBC_URL=${SPRING_DATASOURCE_HIKARI_JDBCURL}

      - JDBC_USERNAME=${SPRING_DATASOURCE_HIKARI_USERNAME}

      - JDBC_PASSWORD=${SPRING_DATASOURCE_HIKARI_PASSWORD}

      - SPRING_DATASOURCE_HIKARI_JDBCURL=${SPRING_DATASOURCE_HIKARI_JDBCURL}

      - SPRING_DATASOURCE_HIKARI_USERNAME=${SPRING_DATASOURCE_HIKARI_USERNAME}

      - SPRING_DATASOURCE_HIKARI_PASSWORD=${SPRING_DATASOURCE_HIKARI_PASSWORD}

      - SPRING_METADATASOURCE_HIKARI_JDBCURL=${SPRING_METADATASOURCE_HIKARI_JDBCURL}

      - SPRING_METADATASOURCE_HIKARI_USERNAME=${SPRING_METADATASOURCE_HIKARI_USERNAME}

      - SPRING_METADATASOURCE_HIKARI_PASSWORD=${SPRING_METADATASOURCE_HIKARI_PASSWORD}

      - ALARM_MAIL_SERVER_URL=${ALARM_MAIL_SERVER_URL}

      - ALARM_MAIL_SERVER_PORT=${ALARM_MAIL_SERVER_PORT}

      - ALARM_MAIL_SERVER_USERNAME=${ALARM_MAIL_SERVER_USERNAME}

      - ALARM_MAIL_SERVER_PASSWORD=${ALARM_MAIL_SERVER_PASSWORD}

      - ALARM_MAIL_SENDER_ADDRESS=${ALARM_MAIL_SENDER_ADDRESS}

      - ALARM_MAIL_TRANSPORT_PROTOCOL=${ALARM_MAIL_TRANSPORT_PROTOCOL}

      - ALARM_MAIL_SMTP_PORT=${ALARM_MAIL_SMTP_PORT}

      - ALARM_MAIL_SMTP_AUTH=${ALARM_MAIL_SMTP_AUTH}

      - ALARM_MAIL_SMTP_STARTTLS_ENABLE=${ALARM_MAIL_SMTP_STARTTLS_ENABLE}

      - ALARM_MAIL_SMTP_STARTTLS_REQUIRED=${ALARM_MAIL_SMTP_STARTTLS_REQUIRED}

      - ALARM_MAIL_DEBUG=${ALARM_MAIL_DEBUG}

    links:

      - "pinpoint-mysql:pinpoint-mysql"

    networks:

      - pinpoint

  pinpoint-agent:

    build:

      context: ./pinpoint-agent/

      dockerfile: Dockerfile

      args:

        - PINPOINT_VERSION=${PINPOINT_VERSION}

    container_name: "${PINPOINT_AGENT_NAME}"

    image: "pinpointdocker/pinpoint-agent:${PINPOINT_VERSION}"

    restart: unless-stopped

    networks:

      - pinpoint

    volumes:

      - data-volume:/pinpoint-agent

    environment:

      - SPRING_PROFILES=${SPRING_PROFILES}

      - COLLECTOR_IP=${COLLECTOR_IP}

      - PROFILER_TRANSPORT_AGENT_COLLECTOR_PORT=${PROFILER_TRANSPORT_AGENT_COLLECTOR_PORT}

      - PROFILER_TRANSPORT_METADATA_COLLECTOR_PORT=${PROFILER_TRANSPORT_METADATA_COLLECTOR_PORT}

      - PROFILER_TRANSPORT_STAT_COLLECTOR_PORT=${PROFILER_TRANSPORT_STAT_COLLECTOR_PORT}

      - PROFILER_TRANSPORT_SPAN_COLLECTOR_PORT=${PROFILER_TRANSPORT_SPAN_COLLECTOR_PORT}

      - PROFILER_SAMPLING_TYPE=${PROFILER_SAMPLING_TYPE}

      - PROFILER_SAMPLING_COUNTING_SAMPLING_RATE=${PROFILER_SAMPLING_COUNTING_SAMPLING_RATE}

      - PROFILER_SAMPLING_PERCENT_SAMPLING_RATE=${PROFILER_SAMPLING_PERCENT_SAMPLING_RATE}

      - PROFILER_SAMPLING_NEW_THROUGHPUT=${PROFILER_SAMPLING_NEW_THROUGHPUT}

      - PROFILER_SAMPLING_CONTINUE_THROUGHPUT=${PROFILER_SAMPLING_CONTINUE_THROUGHPUT}

      - DEBUG_LEVEL=${AGENT_DEBUG_LEVEL}

      - PROFILER_TRANSPORT_MODULE=${PROFILER_TRANSPORT_MODULE}

    depends_on:

      - pinpoint-collector

  #zookeepers

  zoo1:

    image: zookeeper:3.4.13

    restart: always

    hostname: zoo1

    expose:

      - "2181"

      - "2888"

      - "3888"

    ports:

      - "2181"

    environment:

      ZOO_MY_ID: 1

      ZOO_SERVERS: server.1=0.0.0.0:2888:3888 server.2=zoo2:2888:3888 server.3=zoo3:2888:3888

    networks:

      - pinpoint

  zoo2:

    image: zookeeper:3.4.13

    restart: always

    hostname: zoo2

    expose:

      - "2181"

      - "2888"

      - "3888"

    ports:

      - "2181"

    environment:

      ZOO_MY_ID: 2

      ZOO_SERVERS: server.1=zoo1:2888:3888 server.2=0.0.0.0:2888:3888 server.3=zoo3:2888:3888

    networks:

      - pinpoint

  zoo3:

    image: zookeeper:3.4.13

    restart: always

    hostname: zoo3

    expose:

      - "2181"

      - "2888"

      - "3888"

    ports:

      - "2181"

    environment:

      ZOO_MY_ID: 3

      ZOO_SERVERS: server.1=zoo1:2888:3888 server.2=zoo2:2888:3888 server.3=0.0.0.0:2888:3888

    networks:

      - pinpoint

  ##flink

  jobmanager:

    build:

      context: pinpoint-flink

      dockerfile: Dockerfile

      args:

        - PINPOINT_VERSION=${PINPOINT_VERSION}

    container_name: "${PINPOINT_FLINK_NAME}-jobmanager"

    image: "pinpointdocker/pinpoint-flink:${PINPOINT_VERSION}"

    expose:

      - "6123"

    ports:

      - "${FLINK_WEB_PORT:-8081}:8081"

    command: standalone-job -p 1 pinpoint-flink-job.jar -spring.profiles.active release

    environment:

      - JOB_MANAGER_RPC_ADDRESS=jobmanager

      - PINPOINT_ZOOKEEPER_ADDRESS=${PINPOINT_ZOOKEEPER_ADDRESS}

    networks:

      - pinpoint

    depends_on:

      - zoo1

  taskmanager:

    build:

      context: pinpoint-flink

      dockerfile: Dockerfile

      args:

        - PINPOINT_VERSION=${PINPOINT_VERSION}

    container_name: "${PINPOINT_FLINK_NAME}-taskmanager"

    image: "pinpointdocker/pinpoint-flink:${PINPOINT_VERSION}"

    expose:

      - "6121"

      - "6122"

      - "19994"

    ports:

      - "6121:6121"

      - "6122:6122"

      - "19994:19994"

    depends_on:

      - zoo1

      - jobmanager

    command: taskmanager

    links:

      - "jobmanager:jobmanager"

    environment:

      - JOB_MANAGER_RPC_ADDRESS=jobmanager

    networks:

      - pinpoint

  redis:

    image: redis:7.0.14

    restart: always

    hostname: pinpoint-redis

    ports:

      - "6379:6379"

    networks:

      - pinpoint

volumes:

  data-volume:

  mysql_data:

  hbase_data:

networks:

  pinpoint:

    driver: bridge

    ipam:

      config:

        - Subnetz: ${PINPOINT_NETWORK_SUBNET}

Die Erklärung der Komponenten, die wir in den docker-compose YAML-Dateien verwendet haben
‍
1. Services

Services sind die einzelnen Container, aus denen die Anwendung besteht. Jeder Service läuft in seinem eigenen Container, kann aber mit anderen Services interagieren, die in derselben docker-compose.yml-Datei definiert sind.

a. pinpoint-hbase

• Zweck: Pinpoint verwendet HBase als primären Speicher zum Speichern von Tracing-Daten.
• Build: Der Service wird aus einem Dockerfile erstellt, das sich im Verzeichnis ./pinpoint-hbase/ befindet.
• Umgebungsvariablen: Diese Variablen definieren verschiedene TTL (Time-to-Live)-Einstellungen für verschiedene Arten von Daten, die in HBase gespeichert sind.
• Volumes: Persistenter Speicher für HBase-Daten wird auf dem Host gemountet, um die Datenpersistenz über Container-Neustarts hinweg zu gewährleisten.
• Ports: Der Service stellt mehrere Ports für die Kommunikation bereit (60000, 16010, 60020, 16030).
• Depends_on: Dies stellt sicher, dass der zoo1 (Zookeeper)-Service vor pinpoint-hbase startet.

b. pinpoint-mysql

• Zweck: MySQL wird zur Speicherung von Anwendungsmetadaten und anderen relationalen Daten verwendet, die von Pinpoint benötigt werden.
• Image: Es wird ein MySQL 8.0 Image von Docker Hub verwendet.
• Umgebungsvariablen: Dazu gehören MySQL-Anmeldeinformationen wie Root-Passwort, Benutzer, Passwort und Datenbankname.
• Volumes: Persistenter Speicher für MySQL-Daten wird auf dem Host gemountet.
• Ports: Der MySQL-Dienst wird auf Port 3306 freigegeben.

c. pinpoint-web

• Zweck: Dies ist die Web-Benutzeroberfläche für Pinpoint, die es Benutzern ermöglicht, die Tracing-Daten zu visualisieren und zu analysieren.
• Build: Der Dienst wird aus einem Dockerfile im Verzeichnis ./pinpoint-web/ erstellt.
• Abhängigkeiten: Dies stellt sicher, dass die Dienste pinpoint-hbase, pinpoint-mysql, zoo1 und redis laufen, bevor der Webdienst gestartet wird.
• Umgebungsvariablen: Diese konfigurieren den Webdienst, einschließlich Datenbankverbindungen, Logging-Levels und anderer Eigenschaften.
• Ports: Der Dienst gibt Port 9997 für die Weboberfläche frei.

d. pinpoint-collector

• Zweck: Der Collector-Dienst sammelt Trace-Daten von Anwendungen und speichert sie in HBase.
• Erstellung: Der Dienst wird aus einem Dockerfile erstellt, das sich im Verzeichnis ./pinpoint-collector/ befindet.
• Abhängigkeiten: Dies stellt sicher, dass die Dienste pinpoint-hbase, zoo1 und redis laufen, bevor der Collector gestartet wird.
• Umgebungsvariablen: Diese konfigurieren den Collector-Dienst, einschließlich seiner Verbindung zu HBase, Zookeeper und der Protokollierungsstufen.
• Ports: Der Collector stellt mehrere Ports (9991-9996) für verschiedene Kommunikationsarten (gRPC, UDP usw.) bereit.
• Netzwerke: Der Collector-Dienst ist Teil des Pinpoint-Netzwerks und verwendet eine feste IP-Adresse.

e. zoo1

• Zweck: Zookeeper wird zur Verwaltung und Koordination der verteilten Komponenten von Pinpoint eingesetzt.
• Image: Ein Zookeeper-Image (3.4.14) von Docker Hub wird verwendet.
• Umgebungsvariablen: Diese konfigurieren die Zookeeper-Instanz.
• Ports: Der Dienst ist für die Zookeeper-Kommunikation auf Port 2181 verfügbar.

f. redis

• Zweck: Redis wird als Caching-Schicht für Pinpoint verwendet, um die Leistung zu verbessern.
• Image: Es wird ein Redis-Image (5.0.6) von Docker Hub verwendet.
• Ports: Der Redis-Dienst ist auf Port 6379 verfügbar.

2. Netzwerke

Netzwerke ermöglichen die Kommunikation der Dienste untereinander. In dieser docker-compose.yml ist ein benutzerdefiniertes Bridge-Netzwerk namens pinpoint definiert.

• pinpoint: Dies ist ein benutzerdefiniertes Bridge-Netzwerk, das allen Diensten die Kommunikation untereinander in einem privaten Netzwerk ermöglicht. Jeder Dienst kann andere über deren Dienstnamen erreichen.

3. Volumes

Volumes bieten persistenten Speicher, der Container-Neustarts überdauert. Sie werden verwendet, um von Diensten (wie Datenbanken) generierte Daten zu speichern.

• hbase_data: Ein Volume zum Speichern von HBase-Daten.
• mysql_data: Ein Volume zum Speichern von MySQL-Daten.

4. Umgebungsvariablen

Umgebungsvariablen werden zur Laufzeit zur Konfiguration der Dienste verwendet. Dazu können Datenbankzugangsdaten, Logging-Stufen, Ports und andere Konfigurationsdetails gehören. Jeder Dienst definiert seinen eigenen Satz von Umgebungsvariablen, zugeschnitten auf seine spezifischen Anforderungen.

5. Ports

Ports werden freigegeben, um externen Zugriff auf die Dienste zu ermöglichen. Zum Beispiel:

• 3306:3306 für MySQL
• 9997:9997 für die Pinpoint Web-UI
• 6379:6379 für Redis

6. Neustartrichtlinien

Neustartrichtlinien (restart: always) stellen sicher, dass die Container automatisch neu gestartet werden, wenn sie anhalten oder abstürzen. Dies trägt dazu bei, die hohe Verfügbarkeit der Dienste aufrechtzuerhalten.

7. Links

Links ermöglichen Containern die Kommunikation untereinander mittels Hostnamen. In dieser docker-compose.yml sind die Dienste pinpoint-web und pinpoint-collector mit dem Dienst pinpoint-mysql verknüpft, um die Datenbankkommunikation zu erleichtern.

8. Expose vs. Ports

• Expose: Dies ermöglicht Containern die interne Kommunikation untereinander, ohne die Ports der Hostmaschine freizugeben.
• Ports: Diese bilden die Container-Ports auf die Hostmaschine ab, wodurch externer Zugriff auf die Dienste ermöglicht wird.

Anschließend müssen die folgenden Ports auf die Whitelist gesetzt werden 8080, 80 und 443  in den Sicherheitsgruppen.

Das Dashboard ist unten zu sehen.

Pinpoint in die Node.js-Anwendung integrieren:

Wir müssen den Pinpoint-Agenten in die Node.js-Anwendung importieren.
Befehle, die nach dem Import des Pinpoint-Agenten ausgeführt werden sollen:

Installation mit npm:

npm install --save pinpoint-node-agent

Installation mit yarn:

yarn add pinpoint-node-agent

Code hinzufügen:

Um den Pinpoint-Agenten für Anwendungen auszuführen, müssen wir zunächst sicherstellen, dass die Voraussetzungen erfüllt sind.

CommonJS

require('pinpoint-node-agent')

Wenn wir pm2 verwenden, nutzen Sie node-args (CLI) oder node_args (Ecosystem-Datei).

module.exports = {

  apps : [{

    name: "app",

    script: "./app.js",

    'node_args': ['-r', 'pinpoint-node-agent']

  }]

}

Nachfolgend das beigefügte Beispiel:

Mit Umgebungsvariablen konfigurieren und die Anwendung starten

‍
Basierend auf der Datei pinpoint-config-default.json auf dem Server werden nur die notwendigen Teile als Umgebungsvariablen festgelegt.

PINPOINT_AGENT_ID=${HOSTNAME} PINPOINT_APPLICATION_NAME=Test-Node-App PINPOINT_COLLECTOR_IP=<pinpoint server private-ip> PINPOINT_ENABLE=true pm2 start ~/application path/app.js

Sobald die Anwendung läuft, überprüfen Sie die Seite. Die Ausgabe ist nachfolgend dargestellt.

Fazit

Durch Befolgen dieser Schritte konnten wir Pinpoint APM erfolgreich einrichten, um unsere Node.js-Anwendung zu überwachen. Mit Pinpoint erhalten wir tiefe Einblicke in die Leistung unserer Anwendung, können Engpässe identifizieren und unseren Code optimieren, um eine reibungslose und effiziente Benutzererfahrung zu gewährleisten. Die Echtzeitüberwachung und die umfassenden Tracing-Funktionen von Pinpoint machen es zu einem unschätzbaren Werkzeug für die Verwaltung der Leistung unserer Anwendungen.
‍

Referenzen

‍
https://github.com/pinpoint-apm

https://github.com/pinpoint-apm/pinpoint

https://github.com/pinpoint-apm/pinpoint-node-agent

https://www.baeldung.com/ops/pinpoint-intro 

Übersicht

Die Migration einer virtuellen Maschineninstanz (VM) von Google Cloud Platform (GCP) zu Amazon Web Services (AWS) kann beängstigend wirken. Doch mit den richtigen Tools und einem Schritt-für-Schritt-Prozess ist sie machbar. In diesem Beitrag führen wir Sie durch den gesamten Prozess und gestalten den Übergang von GCP zu AWS reibungslos. Hier verwenden wir das native AWS-Tool, Application Migration Service, um eine VM-Instanz von GCP zu AWS zu migrieren.

Architekturdiagramm

Schritt-für-Schritt-Anleitung

Schritt 1: Einrichtung in GCP

Eine Test-Windows-VM-Instanz starten

Gehen Sie zu Ihrer GCP-Konsole und erstellen Sie eine Test-Windows-VM. Für dieses Beispiel haben wir eine 51 GB große Boot-Disk erstellt. Dies wird unsere Quell-VM sein.

Per RDP auf den Windows Server zugreifen

Stellen Sie als Nächstes eine RDP-Verbindung zu Ihrem Windows Server her. Sobald die Verbindung hergestellt ist, müssen Sie den AWS Application Migration Service (AMS)-Agenten auf diesem Server installieren.

AMS-Agent installieren

Um den AMS-Agenten zu installieren, laden Sie ihn mit dem folgenden Befehl herunter:

https://aws-application-migration-service-us-east-1.s3.us-east-1.amazonaws.com/latest/windows/AwsReplicationWindowsInstaller.exe

Weitere Details finden Sie in der AWS-Dokumentation: https://docs.aws.amazon.com/mgn/latest/ug/windows-agent.html

Schritt 2: AMS-Agent installieren

Navigieren Sie zum Downloads-Ordner und öffnen Sie den AWS-Agenten mit Administratorrechten über die Eingabeaufforderung.

 Bei der Installation werden Sie aufgefordert, die AWS-Region auszuwählen, in die repliziert werden soll. Für diese Anleitung haben wir N.V. gewählt.

Schritt 3: AWS-Konsole vorbereiten

Benutzer erstellen und Berechtigungen zuweisen

Erstellen Sie in der AWS-Konsole einen neuen Benutzer und weisen Sie ihm eine AWS-Replikationsberechtigungsrolle zu. Generieren Sie Zugriffs- und geheime Schlüssel für diesen Benutzer.

Beim Erstellen der Schlüssel wählen Sie die Option „Drittanbieterdienst“ für diesen Schlüssel.

Schlüssel in den GCP Windows Server eingeben

Geben Sie den Zugriffs- und geheimen Schlüssel in den GCP Windows Server ein. Der AMS-Agent fragt, welche Festplatten repliziert werden sollen (z. B. Laufwerke C und D). Für dieses Beispiel haben wir einfach die Eingabetaste gedrückt, um alle Festplatten zu replizieren.

Sobald dies erledigt ist, installiert sich der AMS-Agent und beginnt mit der Replikation Ihrer Daten.

In unserem AWS-Konto wurde eine Instanz erstellt:

Nach der Installation des AMS-Agenten auf dem Quell-Windows-Server in GCP wurde ein Replikationsserver in der AWS EC2-Konsole erstellt. Diese Instanz wurde verwendet, um alle VM-Instanzdaten vom GCP-Konto in das AWS-Konto zu replizieren.

Schritt 4: Datenmigration überwachen

 Gehen Sie in Ihrem AWS-Konto zum Application Migration Service. In der Spalte der Quellserver sollte Ihre GCP-VM-Instanz aufgeführt sein.

Die Datenmigration wird gestartet und Sie können sie überwachen. Je nach Größe Ihrer Boot-Disk und der Datenmenge kann dies einige Zeit in Anspruch nehmen.

Es dauerte über eine halbe Stunde, die Daten von einer 51 GB großen Boot-Disk einer GCP-VM-Instanz zu AWS zu migrieren. Nach Abschluss war sie bereit für die Testphase.

Schritt 5: Startvorlage erstellen‍

Nachdem die Datenmigration abgeschlossen ist, erstellen Sie eine Startvorlage für Ihren Anwendungsfall. Diese Startvorlage sollte Instanztyp, Schlüsselpaar, VPC-Bereich, Subnetze usw. enthalten. Die neue EC2-Instanz wird von dieser Vorlage aus gestartet.

‍Schritt 6: Replikationsvorlage erstellen

Erstellen Sie auf ähnliche Weise eine Replikationsvorlage. Diese Vorlage repliziert Ihre Daten in Ihre neue AWS-Umgebung.

‍Schritt 7: Eine EC2-Testinstanz starten

Sobald die Vorlagen eingerichtet sind, starten Sie eine EC2-Testinstanz von der Boot-Disk Ihrer Quell-GCP-VM-Instanz. Erstellen Sie einen Snapshot Ihrer Instanz, um die Datenintegrität zu gewährleisten. Die Testinstanz sollte erfolgreich starten und Ihrer ursprünglichen GCP-VM entsprechen. Dies ist automatisiert, es sind keine manuellen Migrationsschritte erforderlich. [SEG 6] Sobald wir eine Test-EC2-Instanz starten, geschieht alles automatisch und die Test-EC2-Instanz wird gestartet. Nachfolgend sehen Sie den automatisierten Prozess zum Starten der EC2-Instanz. Siehe Screenshot.

Sobald dies geschehen ist, werden die Daten mithilfe des Replikationsservers des AWS Application Migration Service von GCP zu AWS migriert. Die Test-EC2-Instanz können Sie wie unten gezeigt in der AWS EC2-Konsole sehen.

Konfiguration der Test-EC2-Instanz zu Ihrer Information:

Schritt 8: Letzte Umstellungsphase

Sobald die Umstellung abgeschlossen und eine neue EC2-Instanz gestartet wurde, werden die Test-EC2-Instanz und der Replikationsserver beendet, und wir haben die neue EC2-Instanz mit unserer benutzerdefinierten Konfiguration. Siehe Screenshot unten.

Schritt 9: Die EC2-Instanz überprüfen

Melden Sie sich über RDP bei der neuen EC2-Instanz an und überprüfen Sie, ob alle Daten migriert wurden. Stellen Sie sicher, dass alle Daten intakt und zugänglich sind, und prüfen Sie auf Unstimmigkeiten. Unsere neue EC2-Instanz sehen Sie unten:

‍

Schritt 10: Ihre Anwendung testenNachdem Sie die Daten überprüft haben, testen Sie Ihre Anwendung, um sicherzustellen, dass sie in der neuen AWS-Umgebung wie erwartet funktioniert. Wir haben unsere Beispiel-Webanwendung getestet, und sie funktionierte. [SEG 16] Fazit

Die Migration einer VM-Instanz von GCP zu AWS ist ein mehrstufiger Prozess, der jedoch mit der richtigen Planung und Ausführung reibungslos durchgeführt werden kann. Befolgen Sie diese Anleitung, und Ihre Daten werden sicher migriert und Ihre Anwendungen reibungslos in der neuen Umgebung laufen.

AWS, Virtuelle Maschine, GCP

Migration einer VM-Instanz von GCP zu AWS: Eine Schritt-für-Schritt-Anleitung

Bei Ankercloud spiegelt sich unser Engagement für Informationssicherheit in unserer ISO 27001:2022-Zertifizierung wider. Mit unserer Expertise und fortschrittlichen Tools unterstützen wir andere Organisationen dabei, dieselbe Zertifizierung effizient zu erreichen. Mit Vanta gewährleisten wir einen optimierten, automatisierten und effektiven Compliance-Prozess, der unser Engagement für höchste Informationssicherheitsstandards unterstreicht.

Was ist ISO 27001:2022?

ISO 27001:2022 ist ein globaler Standard für die Verwaltung und den Schutz sensibler Unternehmensinformationen durch ein Informationssicherheits-Managementsystem (ISMS). Er gewährleistet die Vertraulichkeit, Integrität und Verfügbarkeit von Daten, indem er einen strukturierten Ansatz zur Steuerung von Informationssicherheitsrisiken bietet.

Der ISO 27001:2022-Prozess (Traditioneller Ansatz)

Die Erlangung der ISO 27001-Zertifizierung erfordert die folgenden entscheidenden Schritte

Vorbereitung (1-3 Monate) 

Sich mit dem Standard vertraut machen, den Geltungsbereich definieren und eine erste Gap-Analyse durchführen

Implementierung (3-6 Monate) 

Ein ISMS entwickeln, Risikobewertungen durchführen, notwendige Kontrollen implementieren und Richtlinien dokumentieren

Internes Audit (1-2 Monate) 

Die Einhaltung des ISMS bewerten und Verbesserungen identifizieren

Management-Review (1 Monat) 

Die ISMS-Leistung überprüfen und an den Unternehmenszielen ausrichten

Zertifizierungsaudit (1-2 Monate) 

Eine Zertifizierungsstelle für die Audits der Stufe 1 (Dokumentenprüfung) und Stufe 2 (Vor-Ort-Bewertung) beauftragen

Nach der Zertifizierung (laufend) 

Kontinuierlich überwachen, interne Audits durchführen und Management-Reviews vornehmen

Insgesamt kann der Prozess etwa 6 bis 12 Monate dauern, abhängig von Faktoren wie der Größe, Komplexität und Vorbereitung der Organisation.

Wie Vanta die ISO 27001:2022-Compliance vereinfacht

Vanta, eine Plattform zur Compliance-Automatisierung, transformiert den Compliance-Prozess durch die Automatisierung von Sicherheitsüberwachung und Nachweiserfassung, wodurch die Einhaltung von ISO 27001:2022 einfacher wird. So funktioniert's:

1. Automatisierte Sicherheitsüberwachung: Vanta überwacht Ihre Systeme kontinuierlich auf Sicherheitsprobleme und stellt sicher, dass Sie die Anforderungen der ISO 27001:2022 ohne manuelles Eingreifen erfüllen.
2. Nachweiserfassung: Vanta automatisiert 90 % der Nachweiserfassung, wie z. B. Zugriffsprotokolle, Sicherheitskonfigurationen und Compliance-Statusberichte.
3. Compliance-Management: Ein zentralisiertes Dashboard hilft bei der Verwaltung und Verfolgung von Compliance-Bemühungen und vereinfacht den Prozess.
4. Risikobewertung: Vanta identifiziert Schwachstellen und Risiken und liefert effektive Empfehlungen.
5. Automatisierte Dokumentation: Erstellt und pflegt die erforderliche Dokumentation für Audits, wodurch der manuelle Arbeitsaufwand reduziert wird.

Mit Vantas Automatisierungsansatz kann der ISO 27001:2022-Zertifizierungsprozess erheblich beschleunigt werden, sodass Unternehmen die Zertifizierung in nur 2 bis 3 Monaten erreichen können. Dieser beschleunigte Zeitplan wird durch Vantas effiziente, automatisierte Workflows und die kontinuierliche Überwachung ermöglicht, die Compliance-Aufgaben optimieren und den Zeitaufwand reduzieren, der typischerweise für manuelle Prozesse erforderlich ist.

Vorteile der Nutzung von Vanta Compliance-Tools im Vergleich zu traditionellen Methoden

Vanta bietet zahlreiche Vorteile gegenüber traditionellen Compliance-Methoden:

1. Vereinfachtes Management und Anleitung: Reduziert Komplexitäten und bietet eine Schritt-für-Schritt-Anleitung, wodurch der administrative Aufwand gesenkt wird.
2. Automatisierte Erkennung und proaktive Bewertung: Gewährleistet die rechtzeitige Identifizierung und Priorisierung von Sicherheitsrisiken.
3. Echtzeit-Dashboards und optimierte Audits: Bietet sofortige Transparenz über den Compliance-Status und vereinfacht die Audit-Vorbereitung.‍
4. Nahtlose Integration und benutzerfreundliche Oberfläche: Steigert die Workflow-Effizienz durch nahtlose Integration und eine intuitive Benutzeroberfläche.‍
5. Verbesserter Datenschutz und Vertrauensbildung: Stärkt den Datenschutz und demonstriert Stakeholdern starke Sicherheitspraktiken.‍
6. Zeit- und Kostenersparnis durch kontinuierliche Überwachung: Automatisierung reduziert Zeit und Kosten, während kontinuierliche Überwachung langfristige Sicherheit und Compliance gewährleistet.

Wie Ankercloud Unternehmen mithilfe von Vanta zur ISO 27001:2022 Zertifizierung verhelfen kann

Als ISO 27001:2022 zertifizierte Lead-Auditoren verbessert Ankercloud die Informationssicherheitspraktiken von Organisationen und gewährleistet die Einhaltung gesetzlicher und regulatorischer Anforderungen. Wir statten Organisationen mit den Fähigkeiten aus, Risiken effektiv zu managen, und fördern so einen proaktiven Ansatz zum Datenschutz. Die Implementierung von ISO 27001:2022 kann Abläufe optimieren, die Effizienz steigern und Vertrauen bei Kunden und Stakeholdern aufbauen.

• Expertenberatung: Die Expertise von Ankercloud führt Unternehmen effizient durch den ISO 27001:2022 Prozess.
• Plattformnutzung: Vantas Automatisierungs- und Überwachungstools optimieren die Compliance.
• Maßgeschneiderter Support: Maßgeschneiderte Dienstleistungen erfüllen spezifische Unternehmensanforderungen und gewährleisten eine umfassende ISO 27001:2022 Abdeckung.
• Beschleunigter Zeitplan: Vantas automatisierte Prozesse und Ankerclouds Expertise ermöglichen eine schnellere ISO-Zertifizierung.
• Kontinuierliche Verbesserung: Ankercloud hilft, das ISMS nach der Zertifizierung zu pflegen und zu verbessern, um fortlaufende Compliance und Sicherheit zu gewährleisten.

Fazit

Die Expertise von Ankercloud, kombiniert mit den Automatisierungsfunktionen von Vanta, bietet eine leistungsstarke Lösung für Unternehmen, die eine ISO 27001:2022-Zertifizierung anstreben. Durch die Optimierung des Compliance-Prozesses mittels automatisierter Sicherheitsüberwachung, Nachweiserfassung und Compliance-Management hilft Ankercloud Unternehmen, die Zertifizierung effizient und effektiv zu erreichen. Der Einsatz von Vanta gewährleistet einen reibungslosen und kostengünstigen Weg zur Zertifizierung und verbessert so die gesamte Sicherheitslage Ihres Unternehmens.

Understanding Generative AI

Generative AI is a revolutionary branch of artificial intelligence that has the capability to create new content, whether it be conversations, stories, images, videos, or music. At its core, generative AI relies on machine learning models known as foundation models (FMs). These models are trained on extensive datasets and have the capacity to perform a wide range of tasks due to their large number of parameters. This makes them distinct from traditional machine learning models, which are typically designed for specific tasks such as sentiment analysis, image classification, or trend forecasting. Foundation models offer the flexibility to be adapted for various tasks without the need for extensive labeled data and training.

Key Factors Behind the Success of Foundation Models

There are three main reasons why foundation models have been so successful:

1. Transformer Architecture: The transformer architecture is a type of neural network that is not only efficient and scalable but also capable of modeling complex dependencies between input and output data. This architecture has been pivotal in the development of powerful generative AI models.

2. In-Context Learning: This innovative training paradigm allows pre-trained models to learn new tasks with minimal instruction or examples, bypassing the need for extensive labeled data. As a result, these models can be deployed quickly and effectively in a wide range of applications.

3. Emergent Behaviors at Scale: As models grow in size and are trained on larger datasets, they begin to exhibit new capabilities that were not present in smaller models. These emergent behaviors highlight the potential of foundation models to tackle increasingly complex tasks.

Accelerating Generative AI on AWS

AWS is committed to helping customers harness the power of generative AI by addressing four key considerations for building and deploying applications at scale:

1. Ease of Development: AWS provides tools and frameworks that simplify the process of building generative AI applications. This includes offering a variety of foundation models that can be tailored to specific use cases.

2. Data Differentiation: Customizing foundation models with your own data ensures that they are tailored to your organization's unique needs. AWS ensures that this customization happens in a secure and private environment, leveraging your data as a key differentiator.

3. Productivity Enhancement: AWS offers a suite of generative AI-powered applications and services designed to enhance employee productivity and streamline workflows.

4. Performance and Cost Efficiency: AWS provides a high-performance, cost-effective infrastructure specifically designed for machine learning and generative AI workloads. With over a decade of experience in creating purpose-built silicon, AWS delivers the optimal environment for running, building, and customizing foundation models.

AWS Tools and Services for Generative AI

To support your AI journey, AWS offers a range of tools and services:

1. Amazon Bedrock: Simplifies the process of building and scaling generative AI applications using foundation models. 

2. AWS Trainium and AWS Inferentia: Purpose-built accelerators designed to enhance the performance of generative AI workloads.

3. AWS HealthScribe: A HIPAA-eligible service that generates clinical notes automatically.

4. Amazon SageMaker JumpStart: A machine learning hub offering foundation models, pre-built algorithms, and ML solutions that can be deployed with ease.

5. Generative BI Capabilities in Amazon QuickSight: Enables business users to extract insights, collaborate, and visualize data using FM-powered features.

6. Amazon CodeWhisperer: An AI coding companion that helps developers build applications faster and more securely.

By leveraging these tools and services, AWS empowers organizations to accelerate their AI initiatives and unlock the full potential of generative AI.

Some examples of how Ankercloud leverages AWS Gen AI solutions

1. Ankercloud has leveraged Amazon Bedrock and Amazon SageMaker which powers VisionForge which is a  tool to create designs tailored to user’s vision, democratizing creative modeling for everyone. VisionForge was used by our client ‘Arrivae’ a leading interior design organization, where we helped them with a  15% improvement in interior design image recommendations, aligning with user prompts and enhancing the quality of suggested designs. Additionally, the segmentation model's accuracy improvement to 65% allowed for a 10% better personalization of specific objects, significantly enhancing the user experience and satisfaction. Read more

2. Another example of using Amazon SageMaker, Ankercloud worked with  ‘Minalyze’ who are  the world's leading manufacturer of XRF core scanning devices and software for geological data display. We were able to create a ready to use and preconfigured Amazon Sagemaker process for Image object classification and OCR analysis Models along with ML- Ops pipeline. This helped Increase the speed and accuracy of object classification and OCR which leads to increased operational efficiency. Read more

3. Ankercloud has helped Federmeister, a facade building company, address their slow quote generation process by deploying an AI and ML solution leveraging Amazon SageMaker that automatically detects, classifies, and measures facade elements from uploaded images, cutting down the processing time from two weeks to just 8 hours. The system, trained on extensive datasets, achieves about 80% accuracy in identifying facade components. This significant upgrade not only reduced manual labor but also enhanced the company's ability to handle workload fluctuations, greatly improving operational efficiency and responsiveness. Read more

Ankercloud is an Advanced Tier AWS Service Partner, which enables us to harness the power of AWS's extensive cloud infrastructure and services to help businesses transform and scale their operations efficiently. Learn more here

Als Pre-Sales-Ingenieur ist die Erstellung detaillierter Architekturdiagramme entscheidend für meine Rolle. Diese Diagramme, insbesondere solche, die AWS-Dienste darstellen, sind unerlässlich, um komplexe Infrastruktur-Setups effektiv an Kunden zu kommunizieren. Das manuelle Hinzufügen von Titeln zu jedem AWS-Symbol in draw.io ist jedoch repetitiv und zeitaufwändig. Unter engen Fristen oder bei häufigen Aktualisierungen wird es noch schwieriger, sicherzustellen, dass jedes Symbol korrekt beschriftet ist.

Wie dieses Tool mein Problem gelöst hat

Um dieses Problem zu lindern, entdeckte ich ein Python-Skript, das von typex1 erstellt wurde und die Titel-Einfügung für AWS-Symbole in draw.io-Diagrammen automatisiert. So hat dieses Tool meinen Workflow verändert:

1. Zeiteffizienz: Das Skript erkennt AWS-Symbole in der draw.io-Datei automatisch und fügt die offiziellen Dienstnamen als Titel ein. Dadurch entfällt die Notwendigkeit, Titel manuell hinzuzufügen, was besonders bei großen Diagrammen eine erhebliche Zeitersparnis bedeutet.
2. Genauigkeit: Durch die Automatisierung der Titel-Einfügung stellt das Skript sicher, dass alle AWS-Symbole konsistent und korrekt beschriftet sind. Dies reduziert das Risiko von Fehlern oder Auslassungen, die bei manueller Eingabe auftreten könnten.

3. Nahtlose Integration: Das Skript läuft im Hintergrund und überwacht kontinuierlich die draw.io-Datei auf Änderungen. Immer wenn ein neues AWS-Symbol ohne Titel hinzugefügt wird, aktualisiert das Skript die Datei, und draw.io fordert zur Synchronisierung auf. Diese nahtlose Integration bedeutet, dass ich ohne Unterbrechung an meinen Diagrammen weiterarbeiten kann.
4. Fokus auf Kernaufgaben: Da die repetitive Aufgabe der Titel-Einfügung automatisiert ist, kann ich mich stärker auf das Design und die Verfeinerung der Architektur der Diagramme konzentrieren. Dies ermöglicht es mir, den Kunden qualitativ hochwertigere und detailliertere Diagramme zu liefern, was die Gesamtpräsentation und Kommunikation verbessert.

Fazit

Das automatisierte Tool zur Titel-Einfügung hat meine Effizienz und Genauigkeit bei der Erstellung von AWS-Architekturdiagrammen in draw.io erheblich verbessert. Durch die Automatisierung einer repetitiven und fehleranfälligen Aufgabe kann ich mich nun auf die kritischeren Aspekte der Diagrammerstellung konzentrieren und letztendlich bessere Kundenergebnisse liefern.

Danksagungen

Besonderer Dank an typex1 für die Entwicklung dieses unglaublich nützlichen Tools. Die Bemühungen und Beiträge der Open-Source-Community verbessern weiterhin unsere Produktivität und optimieren unsere Arbeitsabläufe. Wenn Sie auf Probleme stoßen oder Verbesserungsvorschläge haben, können Sie uns gerne kontaktieren oder ein Issue im GitHub-Repository.

Durch den Einsatz von Automatisierung können wir Routineaufgaben eliminieren und uns darauf konzentrieren, durch unser technisches Fachwissen Mehrwert zu schaffen. Viel Spaß beim Diagrammieren!

‍

‍