Lerneinheit 2: Erstellen von Komponentenprozessen

Komponentenprozesse beschreiben automatische Tasks, die mit Komponenten ausgeführt werden. Komponentenprozesse können andere Tasks in einer Komponente bereitstellen, installieren, deinstallieren, aktualisieren oder ausführen.

Informationen zu diesem Vorgang

There are three types of processes:

Generic processes run outside the context of components or applications. Generic processes are shown on the top-level Processes tab. You can use generic processes in these instances, for example:
- In conjunction with a number of different component processes that do not fit well into a component template
- When you want to run processes that directly affect IBM® UrbanCode Deploy agents that are unrelated to component, such as changing the agent configuration
Application processes run within the context of applications. In many cases, application processes call component processes. For example, an application process can call the component processes that deploy their associated components.
Component processes run tasks on a single component, such as deploying it, uninstalling it, or running configuration tasks on it.

Processes are lists of steps and connections between those steps. Each step is an individual command that runs on a target computer. Steps can manipulate files, run system commands, download files, and run programs. Plug-ins contribute most of these steps; plug-ins are available that work with many different types of software. For information about steps that are provided by plug-ins, see the documentation for the individual plug-in on IBM developerWorks: IBM UrbanCode Deploy Plug-ins.

Jede Komponente muss mindestens einen Komponentenprozess enthalten, um die Komponente bereitzustellen oder zu installieren. In dieser Lerneinheit erstellen Sie einen Bereitstellungsprozess für jede der drei Komponenten. Später werden Sie einen Anwendungsprozess erstellen, der diese Komponentenprozesse aufruft, um jede Komponente bereitzustellen.

Erstellen eines Komponentenprozesses für die Webkomponente

Der Komponentenprozess für die Webkomponente lädt die neueste Version der Komponentenartefakte herunter und setzt diese Artefakte in den richtigen Ordner.

Informationen zu diesem Vorgang

Befolgen Sie diese Schritte, um den Komponentenprozess zu erstellen, der die Webkomponente bereitstellt:

Vorgehensweise

Klicken Sie auf der Registerkarte Komponenten auf die Komponente JPetStore-WEB.
Klicken Sie auf Prozesse und dann auf Prozess erstellen.
Geben Sie im Fenster Prozess erstellen den Namen Webkomponente bereitstellen an.
Wählen Sie in der Liste Prozesstyp die Option Bereitstellung aus. Diese Liste hat andere Optionen für Prozesse, die Komponenten deinstallieren oder konfigurieren.
Übernehmen Sie die Standardwerte für die anderen Eigenschaften und klicken Sie dann auf Speichern.
Klicken Sie in der Liste der Prozesse auf den neuen Prozess. Der Prozess wird in einem Prozesseditor geöffnet. Dieser Editor zeigt die Schritte im Prozess in grafischer Form als Ablaufdiagramm. Die Felder Start und Beenden stellen den Beginn und das Ende des Prozesses dar. Von hier fügen Sie Schritte dem Prozess hinzu und verknüpfen sie zwischen den Schritten Start und Beenden, um die Reihenfolge der Schritte zu zeigen.
Fügen Sie einen Schritt hinzu, um Dateien aus dem Arbeitsverzeichnis zu entfernen. Der Prozess läuft ohne Arbeitsverzeichnis. Um sicherzustellen, dass Sie die neueste Version der Dateien in der Webkomponente verwendet haben, führen Sie einen Befehl aus, um das Arbeitsverzeichnis zu bereinigen:
1. Erweitern Sie links vom Prozesseditor in der Schrittpalette die Option Dienstprogramme. Im Schrittpalettenmenü werden die verfügbaren Schritte angezeigt. Sie können die Palettenkategorien durchsuchen, um Schritte zu finden, oder oben im Fenster Text im Suchfeld eingeben.
2. Klicken Sie unter FileUtils auf den Schritt Dateien und Verzeichnisse löschen und ziehen Sie ihn in den Prozesseditor. Der Schritt wird zwischen die Schritt Start und Beenden eingefügt. Der eingefügte Schritt wird automatisch mit diesen Schritten verbunden. Das Fenster Eigenschaften bearbeiten öffnet sich und zeigt die Eigenschaften für den Schritt. Einige dieser Eigenschaften gelten nur für den Schritt und andere sind bei allen Schritten gleich.
3. Klicken Sie auf das Symbol Bearbeiten . Das Fenster Eigenschaften bearbeiten wird geöffnet. Geben Sie im Feld Name den Namen als Arbeitsverzeichnis bereinigen ein.
4. Geben Sie im Feld Basisverzeichnis einen einzelnen Punkt ein (.).
5. Geben Sie im Feld Einschließen folgenden Code ein:
```
**/*
```
6. Übernehmen Sie die Standardwerte für die anderen Eigenschaften und klicken Sie dann auf OK.
Der neue Schritt wird als Feld im Prozesseditor angezeigt. Der Prozesseditor sieht wie in der folgenden Abbildung aus:
Fügen Sie einen Schritt hinzu, um die neueste Version der Komponentenartefakte hinzuzufügen. Der Schritt Artefakte herunterladen wird in den meisten Bereitstellungsprozessen verwendet. Dieser Schritt lädt die angegebene Version der Komponentenartefakte auf den Zielcomputer herunter. Wenn Sie den Prozess ausführen, geben Sie an, ob Sie die neueste Version der Komponentenartefakte oder eine spezifische Version verwenden möchten.
1. Tipp: Wenn Sie den ersten Schritt in einen Prozesseditor ziehen, wird dieser Schritt automatisch mit den Schritten Start und Beenden verbunden. Wenn Sie nachfolgende Schritte in den Prozesseditor ziehen, positionieren Sie den Cursor in der Zielposition, sodass der Verbindungspfeil hervorgehoben ist, und positionieren Sie anschließend den Schritt. Der neue Schritt wird automatisch verbunden. Sie können später immer noch die Schrittposition ändern und Schritte manuell miteinander verbinden.
  Erweitern Sie in der Schrittpalette Repositorys und ziehen Sie unter IBM UrbanCode Deploy den Schritt Artefakte herunterladen in den Prozesseditor.
2. Klicken Sie auf das Symbol Bearbeiten und akzeptieren Sie im Fenster Eigenschaften bearbeiten die Standardwerte. Klicken Sie anschließend auf OK.
Fügen Sie einen Schritt hinzu, um den alten Webinhalt aus dem Server zu entfernen:
1. Erweitern Sie Dienstprogramme und ziehen Sie unter "FileUtils" einen anderen Schritt vom Typ Dateien und Verzeichnisse löschen in den Prozesseditor.
2. Geben Sie im Fenster Eigenschaften bearbeiten (klicken Sie auf das Symbol Bearbeiten) den Namen als Alte Inhalte entfernen an.
3. Geben Sie im Feld Basisverzeichnis das folgende Verzeichnis ein:
```
webapps/${p:environment/tomcat.contextroot}
```
  Die Variable steht für den Speicherort, an dem Tomcat Ihre bereitgestellten Dateien speichert. Später geben Sie einen Wert für diese Variable an.
4. Geben Sie im Feld Einschließen das folgende Verzeichnis ein:
```
Bilder
```
5. Geben Sie im Feld Arbeitsverzeichnis die folgende Variable ein:
```
${p:environment/tomcat.home}
```
  Diese Variable stellt den Hauptordner des Tomcat-Web-Servers dar. Sie werden für diese Variable später einen Wert eingeben.
6. Übernehmen Sie die Standardwerte in den anderen Feldern und klicken Sie auf OK.
Fügen Sie einen Schritt hinzu, um den neuen Inhalt auf dem Server bereitzustellen. Dieser Schritt kopiert die Komponentenartefakte auf den Anwendungsserver.
1. Erweitern Sie Dienstprogramme und ziehen Sie unter FileUtils einen Schritt vom Typ Verzeichnis verschieben in den Prozesseditor.
2. Geben Sie im Fenster Eigenschaften bearbeiten den Namen Neuen Inhalt bereitstellen ein.
3. Klicken Sie auf das Symbol Bearbeiten und geben Sie im Feld Quellenverzeichnis einen einzelnen Punkt ein (.).
4. Geben Sie im Feld Zielverzeichnis das folgende Verzeichnis ein:
```
${p:environment/tomcat.home}/webapps/${p:environment/tomcat.contextroot}/
```
5. Geben Sie im Feld Einzuschließende Dateien folgenden Code ein:
```
images/*
```
6. Übernehmen Sie die Standardwerte für die anderen Felder und klicken Sie auf OK.
Jetzt hat der Prozess vier Schritte wie in der folgenden Abbildung:

Jeder Schritt hat drei Symbole in der rechten oberen Ecke des Schritts. Mit dem Symbol Bearbeiten

wird das Fenster Eigenschaften bearbeiten geöffnet. Das X-Symbol

löscht den Schritt. Mit dem Symbol "Kopieren"

wird der Schritt in den Ordner Zwischenablage kopiert, damit Sie ihn verdoppeln können.

Wenn Sie die Maus über einen Schritt bewegen, wird ein Pfeilsymbol über der Mitte des Schritts angezeigt. Dieses Symbol wird verwendet, um manuell Verbindungen zwischen Schritten zu erstellen.

Anzeigen der Pfeilschaltfläche in der Mitte des Schritts

Optional: Wenn Ihre Schritte nicht verbunden sind oder nicht in der richtigen Reihenfolge verbunden sind, können Sie die Schritte wie folgt manuell verbinden:
1. Wenn die Schritte nicht in der richtigen Reihenfolge verbunden sind, entfernen Sie den Verbindungslink zwischen Schritten, indem Sie auf die Symbole X an den betreffenden Linkpfeilen klicken. Ordnen Sie anschließend die Schritte in der richtigen Reihenfolge an.
2. Bewegen Sie den Mauscursor über den Schritt Start und ziehen Sie das Pfeilsymbol auf den Schritt Arbeitsverzeichnis bereinigen. Der Pfeil zwischen diesen Schritten stellt den Ablauf der Aktivitäten von einem Schritt zum nächsten dar, wie in der folgenden Abbildung gezeigt:
3. Ziehen Sie einen Pfeil vom Schritt Arbeitsverzeichnis bereinigen zum Schritt Artefakte herunterladen.
4. Ziehen Sie einen Pfeil vom Schritt Artefakte herunterladen zum Schritt Alte Inhalte entfernen.
5. Ziehen Sie einen Pfeil vom Schritt Alte Inhalte entfernen zum Schritt Neuen Inhalt bereitstellen.
6. Ziehen Sie einen Pfeil vom Schritt Neuen Inhalt bereitstellen auf den Schritt Beenden.
Sie können Schritte in einer Sequenz verbinden wie in diesem Beispiel, oder Schritte parallel ausführen lassen, indem Sie mehrere Links erstellen. Die Prozesse beginnen aber immer mit dem Schritt Start und enden mit dem Schritt Beenden. Die Schrittabfolge in diesem Prozess ist wie folgt:
1. Starten
2. Arbeitsverzeichnis bereinigen
3. Artefakte herunterladen
4. Alte Inhalte entfernen
5. Neuen Inhalt bereitstellen
6. Beenden
Speichern Sie den Prozess, indem Sie auf Speichern klicken.

Ergebnisse

Der vollständige Komponentenprozess für die Webkomponente sieht wie in der folgenden Abbildung gezeigt aus:

Der vollständige Komponentenprozess, der die alte Version der Artefakte entfernt und die neue Version auf dem Anwendungsserver bereitstellt

Erstellen eines Komponentenprozesses für die Anwendungskomponente

Diese Anwendungskomponente besteht aus einer einzigen WAR-Datei. Diese Komponente lädt die neueste Version der WAR-Datei herunter, aktualisiert Werte in der Datei und stellt die Datei auf dem Anwendungsserver bereit.

Vorgehensweise

Klicken Sie auf der Registerkarte Komponenten auf die Komponente JPetStore-APP.
Klicken Sie auf Prozesse und dann auf Prozess erstellen.
Geben Sie im Fenster Prozess erstellen den Namen Anwendungskomponente bereitstellen an.
Wählen Sie in der Liste Prozesstyp die Option Bereitstellung aus.
Übernehmen Sie die Standardwerte für die anderen Eigenschaften und klicken Sie dann auf Speichern.
Klicken Sie in der Liste der Prozesse auf den neuen Prozess, um ihn im Prozesseditor zu öffnen.
Fügen Sie einen Schritt hinzu, um das Arbeitsverzeichnis zu bereinigen. Wie bei der Webkomponente fügen Sie einen Schritt Dateien und Verzeichnisse löschen mit dem Namen Arbeitsverzeichnis bereinigen hinzu und geben einen Punkt im Feld Basisverzeichnis sowie **/* im Feld Einschließen ein.
Fügen Sie einen Schritt hinzu, um die Artefakte herunterzuladen. Wie bei der Webkomponente fügen Sie einen Schritt Artefakte herunterladen hinzu und übernehmen die Standardeigenschaften.
Fügen Sie einen Schritt hinzu, um die WAR-Datei zu extrahieren. Sie müssen die WAR-Datei extrahieren, damit Sie eine Eigenschaftendatei mit den Datenbankverbindungsinformationen aktualisieren können.
1. Erweitern Sie in der Liste der verfügbaren Schritte Dienstprogramme und ziehen Sie unter "FileUtils" einen Schritt vom Typ Dekomprimieren in den Prozesseditor.
2. Geben Sie als Namen WAR extrahieren ein.
3. Geben Sie im Feld Verzeichnis extrahieren den folgenden Code ein:
```
./JPetStore_expanded
```
4. Geben Sie im Feld .zip-Dateien die folgende Datei ein:
```
JPetStore.war
```
5. Geben Sie im Feld Einzuschließende Dateien folgenden Code ein:
```
**/*
```
6. Klicken Sie auf OK.
Fügen Sie einen Schritt hinzu, um die Eigenschaftendatei mit der Position der Datenbank zu aktualisieren:
1. Erweitern Sie in der Liste der verfügbaren Schritte Dienstprogramme und fügen Sie aus "FileUtils" einen Schritt vom Typ Java-Eigenschaftendatei aktualisieren zum Prozesseditor hinzu.
2. Geben Sie den Namen mit Eigenschaftendatei aktualisieren an.
3. Geben Sie im Feld Directory Offset folgenden Ordner an:
```
./JPetStore_expanded/WEB-INF/classes/properties
```
4. Geben Sie im Feld Datei schließt ein die folgende Datei an:
```
database.properties
```
5. Geben Sie im Feld Eigenschaften hinzufügen/aktualisieren folgenden Code ein:
```
url=${p:environment/db.url}
```
  Dieser Code aktualisiert die Eigenschaft url in der Eigenschaftendatei mit der Position der Datenbank. Der Code ${p:environment/db.url} ist eine Variable, die die Position der Datenbankkomponente darstellt, wenn die Anwendung bereitgestellt wird.
6. Klicken Sie auf OK.
Fügen Sie einen Schritt hinzu, um die WAR-Datei mit der neuen Eigenschaftendatei zu aktualisieren:
1. Erweitern Sie in der Liste der verfügbaren Schritte Dienstprogramme und fügen Sie aus "FileUtils" einen Schritt vom Typ ZIP-Datei erstellen zum Prozesseditor hinzu.
2. Legen Sie den Namen mit WAR aktualisieren fest.
3. Geben Sie im Feld .zip-Dateiname die Datei JPetStore.war ein.
4. Geben Sie im Feld Basisverzeichnis den folgenden Ordner ein:
```
./JPetStore_expanded
```
5. Geben Sie im Feld Einschließen folgenden Code ein:
```
**/*
```
6. Wählen Sie das Kontrollkästchen Bestehende aktualisieren aus.
7. Klicken Sie auf OK.
Fügen Sie einen Schritt hinzu, um Tomcat zu starten:
1. Erweitern Sie in der Liste der verfügbaren Schritte Anwendungsserver und fügen Sie von "Java/Tomcat" einen Schritt vom Typ Tomcat starten zum Prozesseditor hinzu. Wenn dieser Schritt nicht in der Baumstruktur enthalten ist, installieren Sie das Tomcat-Plug-in gemäß Voraussetzungen in diesem Lernprogramm.
2. Übernehmen Sie den Standardnamen Tomcat starten.
3. Geben Sie im Feld Startprogramm den folgenden Code an:
```
${p:environment/tomcat.start}
```
  Dieser Code ist eine weitere Variable, die den Befehl darstellt, mit dem Tomcat gestartet wird.
4. Geben Sie im Feld Zeitlimit beim Start (in Sekunden) den Wert 60 an.
5. Geben Sie im Feld Port den Port 8081 an.
6. Klicken Sie auf OK.
Fügen Sie einen Schritt hinzu, um frühere Versionen der Anwendung zu entfernen.
1. Erweitern Sie in der Liste der verfügbaren Schritte Anwendungsserver und fügen Sie von "Java/Tomcat" einen Schritt vom Typ Implementierung der Anwendung zurücknehmen zum Prozesseditor hinzu.
2. Übernehmen Sie den Standardnamen Bereitstellung der Anwendung zurücknehmen.
3. Geben Sie im Feld URL für Tomcat Manager folgenden Code ein:
```
${p:environment/tomcat.manager.url}
```
4. Geben Sie im Feld Tomcat Manager-Benutzername den Benutzernamen für den Tomcat-Server an. Sie haben diesen Benutzernamen und sein Kennwort unter Konfigurieren des Agenten und des Zielsystems festgelegt. Wenn Sie die Codebeispiele aus diesem Thema verwenden, sind der Benutzername und das Kennwort tomcatmanager.
5. Geben Sie im Feld Kennwort für Tomcat Manager das Kennwort für den Tomcat-Server ein.
6. Geben Sie im Feld Kontextname den folgenden Kontextnamen einschließlich des Schrägstrichs ein:
```
/${p:environment/tomcat.contextroot}
```
  Achten Sie darauf, dass Sie einen Schrägstrich (/) vor der Variablen einfügen.
7. Klicken Sie auf OK.
Fügen Sie einen Schritt hinzu, um die aktualisierte WAR-Datei auf dem Anwendungsserver bereitzustellen:
1. Erweitern Sie in der Liste der verfügbaren Schritte Anwendungsserver und fügen Sie von "Java/Tomcat" einen Schritt vom Typ Anwendung bereitstellen zum Prozesseditor hinzu.
2. Übernehmen Sie den Standardnamen Anwendung bereitstellen.
3. Geben Sie im Feld URL für Tomcat Manager folgenden Code ein:
```
${p:environment/tomcat.manager.url}
```
4. Geben Sie im Feld Tomcat Manager-Benutzername den Benutzernamen für den Tomcat-Server an.
5. Geben Sie im Feld Kennwort für Tomcat Manager das Kennwort für den Tomcat-Server ein.
6. Geben Sie im Feld Kontextname den folgenden Kontextnamen ein:
```
/${p:environment/tomcat.contextroot}
```
  Achten Sie darauf, dass Sie einen Schrägstrich (/) vor der Variablen einfügen.
7. Geben Sie im Feld Pfad für WAR-Datei den folgenden Pfad ein:
```
./JPetStore.war
```
8. Klicken Sie auf OK.
Optional: Falls erforderlich, ordnen Sie die Schritte in der folgenden Reihenfolge und verbinden Sie sie:
1. Starten
2. Arbeitsverzeichnis bereinigen
3. Artefakte herunterladen
4. WAR extrahieren
5. Eigenschaftendatei aktualisieren
6. WAR extrahieren
7. Tomcat starten
8. Bereitstellung der Anwendung zurücknehmen
9. Anwendung bereitstellen
10. Beenden
Ändern Sie das bedingte Flag auf dem Link zwischen dem Schritt Bereitstellung der Anwendung zurücknehmen und dem Schritt Anwendung bereitstellen auf Beide, indem Sie auf das grüne Häkchen auf der Verbindung klicken, bis es zu einem grauen Kreis wird, wie in der nachfolgenden Abbildung gezeigt:
Jede Verbindung von einem Schritt zu einem anderen hat ein bedingtes Flag. Das bedingte Flag legt eine Bedingung für die Verbindung fest. Die bedingten Flags sind verfügbar:
- Standardmäßig ist das bedingte Flag für jede Verbindung auf Erfolg eingestellt und wird als grünes Häkchen angezeigt. Der Prozess folgt diesen Verbindungen, wenn der Schritt erfolgreich ist.
- Das bedingte Flag fail wird durch ein Ausrufezeichen (!) in einem roten Feld dargestellt. Der Prozess folgt diesen Verbindungen, wenn Schritte fehlschlagen.
- Das bedingte Flag Beide wird durch einen grauen Kreis dargestellt. Der Prozess folgt diesen Verbindungen unabhängig davon, ob ein Schritt erfolgreich ist oder fehlschlägt.
Der Schritt Bereitstellung der Anwendung zurücknehmen schlägt fehl, wenn keine vorherigen Versionen der Anwendung installiert sind. In diesem Fall bestimmt die Einstellung eines bedingten Flags auf der Verbindung zu beiden, dass der Prozess weiter ausgeführt wird, unabhängig davon, ob der Schritt fehlschlägt oder erfolgreich ist.
Speichern Sie den Prozess.

Ergebnisse

Der vollständige Komponentenprozess für die Anwendungskomponente sieht so aus wie in der folgenden Abbildung dargestellt:

Der vollständige Komponentenprozess, der die Anwendung bereitstellt

Erstellen eines Komponentenprozesses für die Datenbankkomponente

Der Bereitstellungsprozess für die Datenbankkomponente aktualisiert die Datenbank mit Beispielwerten.

Vorgehensweise

Klicken Sie auf der Registerkarte Komponenten auf die Komponente JPetStore-DB.
Klicken Sie auf Prozesse und dann auf Prozess erstellen.
Geben Sie im Fenster Prozess erstellen den Namen Datenbankkomponente bereitstellen an.
Wählen Sie in der Liste Prozesstyp die Option Bereitstellung aus.
Übernehmen Sie die Standardwerte für die anderen Eigenschaften und klicken Sie dann auf Speichern.
Klicken Sie in der Liste der Prozesse auf den neuen Prozess, um ihn im Prozesseditor zu öffnen.
Fügen Sie einen Schritt hinzu, um die Artefakte herunterzuladen. Wie bei der Webkomponente fügen Sie einen Schritt Artefakte herunterladen hinzu und übernehmen die Standardeigenschaften.
Fügen Sie einen Schritt hinzu, um die Datenbank zu aktualisieren:
1. Erweitern Sie in der Liste der verfügbaren Schritte Datenbank und fügen Sie unter "DBUpgrader" einen Schritt vom Typ Datenbank aktualisieren zum Prozesseditor hinzu. Wenn dieser Schritt nicht in der Baumstruktur enthalten ist, installieren Sie das Datenbankupgrade-Plug-in gemäß Voraussetzungen in diesem Lernprogramm.
2. Übernehmen Sie im Fenster Eigenschaften bearbeiten im Feld Name den Standardwert Datenbank aktualisieren.
3. Geben Sie im Feld Treiber-Klassenname die folgende Klasse an:
```
com.mysql.jdbc.Driver
```
4. Geben Sie im Feld DB-Treiber-JAR-Datei den folgenden Pfad an:
```
lib/mysql-connector-java-5.1.20-bin.jar
```
  Diese Datei wird im Quellcode für die Komponente verfügbar gemacht.
5. Geben Sie im Feld URL die folgende Variable ein:
```
${p:environment/db.url}
```
6. Geben Sie im Feld Benutzer die Benutzer-ID des Datenbankbenutzers ein. Wenn Sie die Beispiele in Konfigurieren des Agenten und des Zielsystems verwendet haben, ist die Benutzer-ID jpetstore.
7. Geben Sie im Feld Kennwort das Kennwort des Datenbankbenutzers ein. Wenn Sie die Beispiele in Konfigurieren des Agenten und des Zielsystems verwendet haben, ist das Kennwort jppwd.
8. Geben Sie im Feld SQL-Dateipfad einen einzelnen Punkt ein: . .
9. Geben Sie im Feld SQL-Dateieinschlüsse die Option *.xml ein.
10. Geben Sie im Feld Aktuelle SQL-Version den folgenden SQL-Code ein:
```
SELECT VER FROM DB_VERSION WHERE RELEASE_NAME = ?
```
11. Geben Sie im Feld Version-SQL löschen den folgenden SQL-Code ein:
```
DELETE FROM DB_VERSION WHERE RELEASE_NAME = ?
```
12. Geben Sie im Feld SQL-Version aktualisieren den folgenden SQL-Code ein:
```
INSERT INTO DB_VERSION (RELEASE_NAME,VER) VALUES(?,?)
```
13. Klicken Sie auf OK.
Optional: Falls erforderlich, ordnen Sie die Schritte in der folgenden Reihenfolge und verbinden Sie sie:
1. Starten
2. Artefakte herunterladen
3. Datenbank aktualisieren
4. Beenden
Speichern Sie den Prozess.

Ergebnisse

Der vollständige Komponentenprozess für die Datenbankkomponente sieht so aus wie in der folgenden Abbildung dargestellt:

Der vollständige Komponentenprozess, der die Datenbank bereitstellt

Prüfpunkt für die Lerneinheit

In dieser Lerneinheit haben Sie Komponentenprozesse erstellt, um die Komponenten bereitzustellen.

Sie können Komponentenprozesse verwenden, um verschiedene Tasks in Komponenten zu automatisieren. Sie können allerdings Komponentenprozesse nicht direkt ausführen. In den meisten Fällen werden sie Anwendungsprozessen hinzugefügt. Im weiteren Verlauf dieses Lernprogramms erstellen Sie einen Anwendungsprozess für diese drei Komponentenprozesse.

Prozesse bestehen aus Schritten, die von Plug-ins verfügbar gemacht werden. Informationen zum Anzeigen einer Liste der verfügbaren Plug-ins und einer Dokumentation über diese Plug-ins und Schritte finden Sie unter IBM developerWorks: UrbanCode Deploy Plug-ins.

< Zurück | Weiter >

Feedback