ibm urbancode deploy
In deze tutorial leer je over Automatisering van applicatie-implementatie zonder enige handmatige tussenkomst met IBM UrbanCode-implementatie (JBoss-toepassingsserver).
Alle 12 stappen die bij het proces betrokken zijn, samen met de tools, worden hier in detail uitgelegd met duidelijke schermafbeeldingen voor een gemakkelijk en beter begrip.
NOTITIE : Deze tutorial bevat veel afbeeldingen, dus laat deze correct laden.
Wat je leert:
- Wat is IBM UrbanCode Deploy?
- Tools die in deze tutorial worden gebruikt
- Stap # 1: JBoss-configuratie
- Stap 2: UrbanCode Implementeer Login
- Stap 3: controleer de agentstatus
- Stap 4: bestanden toevoegen
- Stap 5: Componenten maken
- Stap 7: Importeer de componentversie
- Stap 8: maak een componentproces
- Stap 9: Maak een applicatie
- Stap 10: Maak een aanvraagproces aan
- Stap 11: implementeer het onderdeel
- Stap 12: Rational Team Concert6.0.2 Build-instellingen na implementatie
- Gevolgtrekking
- Aanbevolen literatuur
Wat is IBM UrbanCode Deploy?
IBM UrbanCode Deploy is een tool voor het automatiseren van applicatie-implementatie via verschillende implementatie-omgevingen zoals Dev, QA, Staging en PROD.
Het is een heel belangrijk hulpmiddel gebruikt voor continue levering in agile ontwikkeling.
UrbanCode Deploy biedt:
- Geautomatiseerde implementaties en rollbacks van applicaties
- Orkestratie van applicatiewijzigingen tussen servers
- Voorraadbeheer
- Duidelijke zichtbaarheid die bepaalt wat en waar artefact wordt ingezet
- Integratie met verschillende J2EE- en .NET-applicatieservers en ITSM-tools
- Integreer met build- en testtools om automatisch nieuwe builds te implementeren, testen en promoten
IBM Rational Team Concert en IBM Urbancode Deploy helpen bij het automatiseren van de CI / CD-stappen:
Tools die in deze tutorial worden gebruikt
- IBM UrbanCode Deploy v6.2.2. Controleer om de UCD 6.2.2-server te installeren hier
- WildFly10.0 Application Server (voorheen bekend als JBoss Application Server)
- JDK 8. Deze versie van JDK is verplicht bij Urbancode Deploy 6.2.2
- Download en installeer de Urbancode Deploy-plug-in voor JBoss van hier
Stap # 1: JBoss-configuratie
Deze tutorial gebruikt WildFly 10.0 (voorheen bekend als JBoss Application Server) als de applicatieserver om een WAR-bestand te implementeren met UrbanCode Deploy.
Start de JBoss-applicatieserver door het bestand uit te voeren standalone.bat. Dit bestand is te vinden in het JBoss-installatiemap bin map.
Notitie: Klik op een afbeelding voor een vergrote weergave)
Voorbeeld WAR-bestand Implementeren via JBoss
Start de CLI-opdracht door het bestand uit te voeren Jboss-cli.bat en typen aansluiten
Stap 2: UrbanCode Implementeer Login
naar) Log in op UrbanCode met deze URL https: //: 8443
b) Installeer het UCD-agent.
Een agent moet draaien op alle doelmachines of omgevingen (QA, Staging enz.) Waar de implementatie wordt uitgevoerd. Een agent implementeert artefacten in de doelomgeving.
c) Ga naar het Help-menu en selecteer het Gereedschap optie.
d) Klik op de link om de zip met het Agent inzetten
is) Pak het ZIP-bestand van de agent uit en voer het bestand uit install-agent.bat om het te installeren.
f) Voorbeeldinstallatie van Agent. Aan het einde van de installatie Niet doen selecteer naar Voer de Agent uit als Windows-service.
g) Voer de agent uit vanaf het Geïnstalleerde directory Selecteer het bestand cmd
h) Agent start in een opdrachtvenster. Sluit deze niet af BLANCO. J minimaliseer het
Stap 3: controleer de agentstatus
Nadat u zich hebt aangemeld bij de IBM UrbanCode Deploy-server, controleert u of de agent online is. Ga naar om te controleren Middelen en selecteer het Agents TAB zoals hieronder weergegeven De agent moet de status Online in hebben GROEN , zoals weergegeven in de volgende afbeelding. Alleen agenten met een onlinestatus kunnen de implementatietaak uitvoeren.
Stap 4: bestanden toevoegen
Voeg bestanden die implementeerbare artefacten vertegenwoordigen toe aan het bestandssysteem, op de computer waarop u de agent hebt geïnstalleerd.
- Maak een map op de computer waarop de agent is geïnstalleerd.
- Maak in deze map een submap met de naam 1.0.
- Kopieer in de map this1.0sub het WAR-bestand van het project. In dit voorbeeld wordt het genoemd HelloWorld-Maven.war
Stap 5: Componenten maken
Componenten zijn doorgaans het 'Wat' van implementatie. Het definieert een inzetbaar stuk applicatie zoals WAR / JAR-bestand, database SQL-bestand enz. In Urbancode Deploy kunt u implementeerbare artefacten importeren vanuit elk buildsysteem, SCM-systeem of bestandssysteem.
In mijn vorige tutorial heb ik je laten zien hoe BUILD wordt gedaan, met behulp van de Rational Team Concert SCM-repository en hoe een J2EE WAR-bestand wordt gegenereerd. In deze tutorial zal ik eerst laten zien hoe we het WAR-bestand importeren vanuit een bestandssysteem en vervolgens zal het tweede deel gaan over hoe een implementatie rechtstreeks vanuit RTC Build naar een omgeving kan worden geautomatiseerd
Om de eerste stap in IBM UrbanCode Deploy te starten, omvat het maken / configureren van componenten en componentprocessen en het toevoegen van de componenten aan applicaties. Vervolgens gebruikt u de processen om de componenten in verschillende omgevingen te implementeren.
De artefacten voor deze voorbeeldcomponent zijn afkomstig van het bestandssysteem waarop de IBM UrbanCode Deploy-agent is geïnstalleerd.
Hoe een JBoss-component te maken:
- Op de Componenten tab klikken Maak een nieuwe component
- Typ in het veld Naam JBoss_Component
- Selecteer Bestandssysteem (met versiebeheer) in de vervolgkeuzelijst Type bronconfiguratie
- Geef in het veld Basispad op d: temp map aangemaakt in stap 4. In deze map bevindt zich een submap met de naam 1.0, die eigenlijk een versie is voor het artefact. We moeten er dus zeker van zijn dat we de temp directory en niet de d: temp 1.0 directory.
- Selecteer het tweede keuzerondje om de componentversie te importeren met behulp van de geïnstalleerde agent
- Aanvaarden de standaardwaarden voor de andere velden op de pagina.
- Klik Opslaan
Stap 7: Importeer de componentversie
- Klik op de Versies tabblad.
- Klik Importeer nieuwe versies De server importeert 1.0 als een nieuwe versie. Als er andere mappen in het Temp directory, ook zij zouden worden geïmporteerd en er zouden ook versies voor hen worden gemaakt.
- De versie 1.0 wordt nu vermeld en het WAR-bestand is binnen
Klik op 1.0 versie
Stap 8: maak een componentproces
Een Component-proces beschrijft verschillende stappen voor het automatiseren van de implementatie zonder handmatige tussenkomst.
In deze stap zullen we een implementatieproces maken voor het JBOSS_Component Later zullen we een aanvraagproces maken dat het onderdeelproces gebruikt om het onderdeel te implementeren. Deze twee stappen zijn vereist om het WAR-bestand effectief te implementeren.
Hoe het componentproces te creëren:
# 1) Op de 'Component: JBOSS_Component ”Pagina, klikt u op het Processen tabblad en klik vervolgens op Maak een nieuw proces
#twee) Typ in het venster Nieuw proces maken _JBoss_Component_Process in het veld Naam.
# 3) Klik op de HelloWorld_JBoss_Component_Process De proceseditor wordt geopend. De proceseditor geeft een overzicht van plug-ins en stappen om de applicatie te implementeren. De 2 stappen - Begin en Af hebben vertegenwoordigen het begin en het einde van het proces en worden automatisch op de editor geplaatst. U moet stappen toevoegen om de toepassing in het proces te implementeren door ze naar de editor te slepen tussen de stappen Start en Voltooien.
naar) Ten eerste uitbreiden Opslagplaatsen Artefact IBM UrbanCode-implementatie op het plugin-palet aan de linkerkant en sleep het Download artefacten stap naar de proceseditor.
Deze stap downloadt de gespecificeerde versie, die later tijdens de implementatie zal worden vermeld, over de componentartefacten naar de recentelijk werkende directory van de agent, wat doorgaans de \ var work .
Dus in de meeste gevallen is dit meestal de eerste stap, aangezien de applicatie (WAR-bestand) wordt gedownload van de UCD-server naar de doelcomputer of de omgeving voor implementatie
Klik op de MIDDEN pictogram om de stap te bewerken
Klik op OK en voeg geen velden toe of wijzig geen velden in deze stap.
b) We zullen nu de volgende stappen uitvoeren om de implementatie te automatiseren.
(i) Stop of schakel de applicatie uit
(ii) Maak de implementatie van de huidige versie die is geïmplementeerd in JBoss AS ongedaan
(iii) Implementeer een nieuwe versie van de applicatie
c) Uitbreiden Applicatie server Java => JBoss en sleep de resterende stappen naar de proceseditor. Voer de waarden in zoals hieronder weergegeven
Waarden voor elke stap
Stap 9: Maak een applicatie
Applicaties beheren componenten en bevatten omgevingen.
Hoe maak je een applicatie aan:
1) Klik op het tabblad Toepassingen en klik vervolgens op Maak een nieuwe applicatie
2) Geef de nieuwe applicatie een naam. , Bijvoorbeeld, HelloWorld-Maven_JBoss_Application
3) Accepteer de standaardwaarden voor de andere velden en klik op Opslaan
4) Voeg het JBOSS_Component naar de applicatie.
5) Klik op het Componenten tabblad en klik vervolgens op Component toevoegen
6) Selecteer in het venster Add, a Component het JBOSS_Component en klik vervolgens op Opslaan. Alleen als er componenten aan een applicatie worden toegevoegd, kan deze worden ingezet.
Stap 10: Maak een aanvraagproces aan
Een aanvraagproces bestaat, net als een onderdeelproces, uit stappen die in de proceseditor worden geconfigureerd. In deze stap maakt u een aanvraagproces dat het JBOSS_Component component door het componentproces aan te roepen dat we eerder hebben gemaakt.
Een aanmeldingsproces aanmaken:
1) Klik op het tabblad Toepassingen en klik vervolgens op het HelloWorldMaven_JBoss_Application
2) Klik Processen en klik vervolgens op Maak een nieuw proces
3) Geef in het venster Een aanvraagproces maken het nieuwe aanvraagproces een naam als HotelWeb_JBoss_Application_Process
4) Accepteer de standaardwaarden voor de andere velden en klik op Opslaan
5) Om het nieuwe proces in de proceseditor te openen, klikt u op het nieuw proces
6) Klik op HelloWorld-Maven_JBoss_Application_Process om de proceseditor te openen.
7) Voeg een stap toe die het JBoss_Component Voeg uit de lijst met stappen aan de linkerkant een Installeer Component stap aan de redacteur.
8) Selecteer in de lijst Component het JBoss_Component Alle componenten die bij een applicatie horen, zijn beschikbaar.
9) Selecteer in de lijst Component Process het HelloWorld-Maven_JBoss_Component_Process
10) Accepteer de standaardwaarden voor de andere velden en klik op Opslaan
11) Verbind de Start-stap met het Installeer JBoss_Component stap.
12) Sluit de Install_JBoss_Component stap naar de stap Voltooien.
13) Sla het proces op door op het Opslaan icoon
Sla het proces op
Stap 11: implementeer het onderdeel
Voordat we beginnen met het implementatieproces, moeten we een resource maken die definieert wat moet worden geïmplementeerd en waar deze moet worden geïmplementeerd. We moeten dus de agent en vervolgens de component aan de bron koppelen.
naar) Klik op de Middelen tabblad bovenaan
b) Klik op de Maak een groep op het hoogste niveau -knop, geef de nieuwe bron een naam zoals JBoss en klik Opslaan
c) Klik Acties> Agent toevoegen naar de bron die zojuist is gemaakt, zoals weergegeven in de volgende afbeelding:
Koppel de agent aan de bron
Koppel de component aan de agent
Klik op Opslaan.
d) Voordat u een implementatie kunt uitvoeren, moet u er minimaal één definiëren milieu die componenten associeert met een agent op de doelhost. Laten we een SIT_Env
is) Open het venster Nieuwe omgeving maken door op te klikken Toepassingen> HelloWorld-Maven_JBoss_Application> Omgevingen> Nieuwe omgeving maken en voer vervolgens de volgende informatie in en klik later op Opslaan
f) Klik op de zojuist aangemaakte omgeving en selecteer Voeg basisbronnen toe. Selecteer de JBoss map en klik op OK
g) Om de component te implementeren, voert u het aanvraagproces uit in de SIT_Env-omgeving.
- Open de applicatiepagina door op te klikken Toepassingen en klik vervolgens op de naam van de applicatie.
- Klik in de omgeving op het Verzoekproces icoon
- Schakel in het venster Proces uitvoeren de standaardwaarde voor de parameter Alleen gewijzigde versies uit.
- Selecteer in de lijst Proces het HelloWorld-Maven_JBoss_Application_Process
- Klik Kies Versies Het venster Componentversies wordt geopend.
- Klik in het venster Componentversies op Voeg toe en selecteer de 1.0-versie. Klik OK om terug te keren naar het venster Proces uitvoeren.
- Klik Verzenden De voortgang wordt weergegeven. Vanaf hier kunt u het proces op de applicatieserver bekijken. De volgende afbeelding toont het lopende proces.
Stap 12: Rational Team Concert6.0.2 Build-instellingen na implementatie
In mijn vorige tutorial hebben we geleerd over het BUILD-proces dat het WAR-bestand van de applicatie heeft gegenereerd. De gemaakte Build-definitie kan nu worden uitgebreid om het bovenstaande UCD-toepassingsproces aan te roepen.
Het voordeel hiervan is dus dat, zodra de BUILD is voltooid, de applicatie automatisch wordt geïmplementeerd in een bepaalde omgeving en niet wacht op het beschikbaar maken van een bron om de applicatie handmatig te implementeren.
Ten eerste moeten we de Build-definitie openen die we in de vorige tutorial hebben gemaakt en de optie Post-Build Deploy inschakelen.
Klik OK na het selecteren van de optie Post-build Deploy. Onthoud ook om OPSLAAN de Build-definitie
Basismap is de map waarin het WAR-bestand zich bevindt nadat de build is voltooid.
Nu wanneer u vraag een build aan en nadat het is voltooid, begint de implementatie automatisch en is er geen handmatige tussenkomst nodig.
interviewvragen voor .net-ontwikkelaars
Gevolgtrekking
In deze tutorial hebben we geleerd hoe de implementatie van een applicatie kan worden geautomatiseerd zonder handmatige tussenkomst met behulp van IBM Urbancode Deploy, een zeer nuttige tool voor DevOps.
Tegenwoordig is het ook erg cruciaal vanuit het oogpunt van automatisering. We kwamen ook te weten hoe het IBM Rational Team Concert BUILD-proces kan worden uitgebreid om de implementatie te automatiseren zodra de build is voltooid.
Deze tutorial was gericht op JBoss als de applicatieserver. U kunt ook andere J2EE-applicatieservers gebruiken, zoals Websphere Application Server, Weblogic, Tomcat enz., Evenals voor automatisering van de implementatie.
Laat ons uw mening / suggesties weten in de opmerkingen hieronder.
Aanbevolen literatuur
- Verschil tussen Desktop, Client Server Testing en Web Testing
- Installeer uw applicatie op het apparaat en begin met testen vanuit Eclipse
- Handleiding voor het testen van webapplicaties
- SQA-processen: hoe een complete applicatie testen?
- Hoe vind je een bug in de applicatie? Tips en trucs
- Java Virtual Machine: hoe JVM helpt bij het uitvoeren van Java-applicaties
- Hoe de gezondheidszorgtoepassing te testen - Deel 1
- AWS Elastic Beanstalk-zelfstudie voor het implementeren van .NET-webtoepassingen