ibm urbancode deploy
Questo tutorial ti istruirà su Automazione della distribuzione delle applicazioni senza alcun intervento manuale utilizzando IBM UrbanCode Deploy (JBoss Application Server).
Tutti i 12 passaggi coinvolti nel processo insieme agli strumenti sono spiegati qui in dettaglio con schermate chiare per una tua facile e migliore comprensione.
NOTA : Questo tutorial ha molte immagini, quindi consenti il caricamento corretto.
Cosa imparerai:
- Cos'è IBM UrbanCode Deploy?
- Strumenti utilizzati in questo tutorial
- Passaggio 1: configurazione JBoss
- Passaggio 2: UrbanCode Deploy Login
- Passaggio 3: verifica dello stato dell'agente
- Passaggio 4: aggiungi file
- Passaggio 5: creazione di componenti
- Passaggio 7: importare la versione del componente
- Passaggio 8: creazione del processo dei componenti
- Passaggio 9: creare un'applicazione
- Passaggio 10: creare il processo di applicazione
- Passaggio 11: distribuire il componente
- Passaggio 12: Impostazioni build post-distribuzione di Rational Team Concert6.0.2
- Conclusione
- Lettura consigliata
Cos'è IBM UrbanCode Deploy?
IBM UrbanCode Deploy è uno strumento per automatizzare la distribuzione delle applicazioni attraverso vari ambienti di distribuzione come Dev, QA, Staging e PROD.
È uno strumento molto importante utilizzato per la consegna continua nello sviluppo agile.
UrbanCode Deploy fornisce:
- Distribuzioni automatizzate e rollback delle applicazioni
- Orchestrazione delle modifiche alle applicazioni tra i server
- Gestione delle scorte
- Chiara visibilità che definisce cosa e dove viene distribuito l'artefatto
- Integrazione con vari server di applicazioni J2EE e .NET e strumenti ITSM
- Integrazione con strumenti di compilazione e test per distribuire, testare e promuovere automaticamente nuove build
IBM Rational Team Concert e IBM Urbancode Deploy aiutano ad automatizzare le fasi CI / CD:
Strumenti utilizzati in questo tutorial
- IBM UrbanCode Deploy v6.2.2. Per installare il server UCD 6.2.2, controllare Qui
- WildFly10.0 Application Server (precedentemente noto come JBoss Application Server)
- JDK 8. Questa versione di JDK è obbligatoria con Urbancode Deploy 6.2.2
- Scarica e installa il plug-in Urbancode Deploy per JBoss da Qui
Passaggio 1: configurazione JBoss
Questo tutorial utilizza WildFly 10.0 (precedentemente noto come JBoss Application Server) come server delle applicazioni per distribuire un file WAR utilizzando UrbanCode Deploy.
Avviare il server delle applicazioni JBoss eseguendo il file standalone.bat. Questo file può essere trovato in Directory di installazione di JBoss bin cartella.
(Nota: Fare clic su qualsiasi immagine per ingrandirla)
File WAR di esempio Distribuito tramite JBoss
Avviare il comando CLI eseguendo il file Jboss-cli.bat e digitando Collegare
Passaggio 2: UrbanCode Deploy Login
per) Accedi a UrbanCode utilizzando questo URL https: //: 8443
b) Installa il file Agente UCD.
Un agente deve essere in esecuzione su tutte le macchine o ambienti di destinazione (QA, gestione temporanea, ecc.) In cui viene eseguita la distribuzione. Un agente esegue il lavoro di distribuzione degli artefatti nell'ambiente di destinazione.
c) Vai al menu Aiuto e seleziona il file Utensili opzione.
d) Fare clic sul collegamento per scaricare lo zip contenente il file Distribuisci agente
e) Estrai il file ZIP dell'agente ed ESEGUI il file install-agent.bat per installarlo.
f) Installazione di esempio dell'agente. Alla fine dell'installazione non selezionare per Esegui l'agente come servizio Windows.
g) Esegui l'agente dal file Directory installata . Seleziona il file cmd
h) L'agente viene avviato in una finestra di comando. Non chiudere questo VUOTO. J ust minimizzarlo
Passaggio 3: verifica dello stato dell'agente
Dopo aver effettuato l'accesso al server IBM UrbanCode Deploy, verificare se l'agente è in linea. Per controllare, vai a Risorse e seleziona il file TAB Agenti come mostrato di seguito . L'agente dovrebbe avere lo stato Online in VERDE , come mostrato nella figura seguente. Solo gli agenti con stato in linea possono eseguire l'attività di distribuzione.
Passaggio 4: aggiungi file
Aggiungi file che rappresentano artefatti distribuibili al file system, sul computer in cui hai installato l'agente.
- Creare una cartella sulla macchina in cui è installato l'agente.
- In questa cartella, crea una sottocartella denominata 1.0.
- Nella cartella this1.0sub, copia il file WAR del progetto. In questo esempio, si chiama HelloWorld-Maven.war
Passaggio 5: creazione di componenti
I componenti sono in genere il 'cosa' della distribuzione. Definisce un'applicazione distribuibile come file WAR / JAR, file SQL di database ecc. In Urbancode Deploy, è possibile importare artefatti distribuibili da qualsiasi sistema di compilazione, sistema SCM o file system.
Nel mio tutorial precedente, ti ho mostrato come viene fatto BUILD, utilizzando il repository SCM di Rational Team Concert e come viene generato un file WAR J2EE. In questo tutorial, mostrerò prima come importiamo il file WAR da un file system e poi la seconda parte riguarderà come una distribuzione può essere automatizzata in un ambiente direttamente da RTC Build
Per avviare il primo passaggio in IBM UrbanCode Deploy include la creazione / configurazione di componenti e processi dei componenti e l'aggiunta dei componenti alle applicazioni. Quindi, si utilizzano i processi per distribuire i componenti in ambienti diversi.
Le risorse per questo componente di esempio provengono dal file system in cui è installato l'agent IBM UrbanCode Deploy.
Come creare il componente JBoss:
- Sul Componenti clic sulla scheda Crea nuovo componente .
- Nel campo Nome, digita JBoss_Component .
- Selezionare File System (con versione) nella casella a discesa Tipo di configurazione origine
- Nel campo Base Path, specificare d: temp cartella creata nel passaggio 4. In questa cartella è presente una sottodirectory denominata 1.0 che è in realtà una versione per l'artefatto. Quindi dobbiamo essere sicuri di utilizzare il file temp directory e non il file d: temp 1.0 directory.
- Selezionare il secondo pulsante di opzione per importare la versione del componente utilizzando l'agente installato
- Accettare i valori predefiniti per gli altri campi della pagina.
- Clic Salva .
Passaggio 7: importare la versione del componente
- Clicca il Versioni tab.
- Clic Importa nuove versioni . Il server importa 1.0 come una nuova versione. Se altre cartelle erano nel file Temp directory, anche loro verrebbero importate e anche le versioni sarebbero state create per loro.
- La versione 1.0 è ora elencata e il File WAR è dentro
Clicca su 1.0 versione
Passaggio 8: creazione del processo dei componenti
Un processo Componente descrive vari passaggi su come automatizzare la distribuzione senza alcun intervento manuale.
In questo passaggio, creeremo un processo di distribuzione per JBOSS_Component . Successivamente, creeremo un processo dell'applicazione che utilizza il processo del componente per distribuire il componente. Questi due passaggi sono necessari per distribuire il file WAR in modo efficace.
Come creare il processo del componente:
# 1) Sul 'Componente: JBOSS_Component ', Fai clic su Processi scheda e quindi fare clic su Crea nuovo processo .
#Due) Nella finestra Crea nuovo processo, digita _JBoss_Component_Process nel campo Nome.
# 3) Clicca sul HelloWorld_JBoss_Component_Process . Si apre l'editor del processo. L'editor del processo elenca i plug-in e i passaggi per distribuire l'applicazione. I 2 passaggi - Inizio e finire rappresentano l'inizio e la fine del processo e vengono automaticamente inseriti nell'editor. È necessario aggiungere passaggi per la distribuzione dell'applicazione al processo trascinandoli nell'editor tra i passaggi Start e Finish.
per) In primo luogo espandere Repository => Artefatto => IBM UrbanCode Deploy nella tavolozza dei plugin a sinistra e trascina il file Scarica artefatti passaggio all'editor del processo.
Questo passaggio scarica la versione specificata, che verrà menzionata in seguito durante la distribuzione, relativa agli artefatti dei componenti nella directory di lavoro recente dell'agente, che in genere è la \ var work .
Quindi nella maggior parte dei casi, questo di solito è il primo passaggio poiché l'applicazione (file WAR) viene scaricata dal server UCD sulla macchina di destinazione o nell'ambiente per la distribuzione
Clicca sul Icona CENTRALE per modificare il passaggio
Fare clic su OK e non aggiungere o modificare alcun campo in questo passaggio.
b) Faremo ora i seguenti passaggi per automatizzare la distribuzione.
(i) Interrompere o disabilitare l'applicazione
(ii) Annullare la distribuzione della versione corrente distribuita in JBoss AS
(iii) Distribuire una nuova versione dell'applicazione
c) Espandere Application Server => Giava => JBoss e trascina i passaggi rimanenti nell'editor del processo. Immettere i valori come mostrato di seguito
Valori per ogni passaggio
Passaggio 9: creare un'applicazione
Le applicazioni gestiscono i componenti e contengono gli ambienti.
Come creare un'applicazione:
1) Fare clic sulla scheda Applicazioni e quindi su Crea nuova applicazione .
2) Assegna un nome alla nuova applicazione. , Per esempio, HelloWorld-Maven_JBoss_Application
3) Accetta i valori predefiniti per gli altri campi, quindi fai clic su Salva
4) Aggiungi il file JBOSS_Component all'applicazione.
5) Fare clic su Componenti scheda e quindi fare clic su Aggiungi componente .
6) Nella finestra Aggiungi, un componente, selezionare il file JBOSS_Component e quindi fare clic su Salva. Solo se i componenti vengono aggiunti a un'applicazione, è possibile distribuirli.
Passaggio 10: creare il processo di applicazione
Un processo dell'applicazione, come un processo componente, è costituito da passaggi configurati nell'editor del processo. In questo passaggio, crei un processo dell'applicazione che installa il file JBOSS_Component componente chiamando il processo componente che abbiamo creato in precedenza.
Come creare un processo di candidatura:
1) Fare clic sulla scheda Applicazioni e quindi su HelloWorldMaven_JBoss_Application .
2) Fare clic su Processi quindi fare clic su Crea nuovo processo .
3) Nella finestra Crea un processo di applicazione, assegna al nuovo processo di applicazione un nome simile a HotelWeb_JBoss_Application_Process .
4) Accetta i valori predefiniti per gli altri campi e fai clic su Salva .
5) Per aprire il nuovo processo nell'editor del processo, fare clic su nuovo processo .
6) Fare clic su HelloWorld-Maven_JBoss_Application_Process per aprire l'editor di processo.
7) Aggiungi un passaggio che distribuisce il JBoss_Component . Dall'elenco dei passaggi a sinistra, aggiungi un file Passaggio di installazione del componente all'editore.
8) Nell'elenco dei componenti, selezionare il file JBoss_Component . Tutti i componenti associati a un'applicazione sono disponibili.
9) Nell'elenco Component Process, selezionare il file HelloWorld-Maven_JBoss_Component_Process
10) Accettare i valori predefiniti per gli altri campi e quindi fare clic su Salva .
11) Collega il passaggio Start al file Installa JBoss_Component passo.
12) Collega il file Install_JBoss_Component passaggio al passaggio Fine.
13) Salvare il processo facendo clic su Salva icona
Salva il processo
Passaggio 11: distribuire il componente
Prima di iniziare il processo di distribuzione, dobbiamo creare una risorsa che definisca cosa dovrebbe essere distribuito e dove dovrebbe essere distribuito. Quindi, dobbiamo collegare l'agente e quindi il componente alla risorsa.
per) Clicca sul Risorse scheda in alto
b) Clicca sul Crea gruppo di primo livello , assegna alla nuova risorsa un nome come JBoss e fare clic Salva .
c) Clic Azioni> Aggiungi agente alla risorsa appena creata, come mostrato nella figura seguente:
Collega l'agente alla risorsa
Collega il componente all'agente
Fare clic su Salva.
d) Prima di poter eseguire qualsiasi distribuzione, è necessario definirne almeno una ambiente che associa i componenti a un agente sull'host di destinazione. Creiamo un file SIT_Env .
e) Aprire la finestra Crea nuovo ambiente facendo clic su Applicazioni> HelloWorld-Maven_JBoss_Application> Ambienti> Crea nuovo ambiente e quindi immettere le seguenti informazioni e in seguito fare clic Salva
f) Fare clic sull'ambiente appena creato e selezionare Aggiungi risorse di base. Seleziona il JBoss cartella e fare clic su ok
g) Per distribuire il componente, eseguire il processo dell'applicazione nell'ambiente SIT_Env.
- Aprire la pagina dell'applicazione facendo clic su Applicazioni e quindi facendo clic sul nome dell'applicazione.
- Nell'ambiente, fare clic su Processo di richiesta icona
- Nella finestra Esegui processo, deselezionare il valore predefinito per il parametro Solo versioni modificate.
- Nell'elenco Processo selezionare il file HelloWorld-Maven_JBoss_Application_Process
- Clic Scegli Versioni . Viene visualizzata la finestra Versioni dei componenti.
- Nella finestra Versioni componente, fare clic su Aggiungi e seleziona la versione 1.0. Clic ok per tornare alla finestra Esegui processo.
- Clic Invia . Viene mostrato l'avanzamento. Da qui è possibile osservare il processo in esecuzione sul server delle applicazioni. La figura seguente mostra il processo in esecuzione.
Passaggio 12: Impostazioni build post-distribuzione di Rational Team Concert6.0.2
Nel mio precedente tutorial, abbiamo imparato a conoscere il processo BUILD che ha generato il file WAR dell'applicazione. La definizione Build creata può ora essere estesa per chiamare il processo di domanda UCD sopra.
Quindi il vantaggio qui è che, una volta che BUILD è stato eseguito, l'applicazione viene distribuita automaticamente in un particolare ambiente, quindi non è in attesa che una risorsa venga resa disponibile per distribuire manualmente l'applicazione.
Per prima cosa dobbiamo aprire la definizione build che abbiamo creato nel tutorial precedente e abilitare l'opzione di distribuzione post-build.
Clic Ok dopo aver selezionato l'opzione Distribuzione post-build. Inoltre, ricordati di farlo SALVA la definizione build
Directory di base è la cartella in cui risiede il file WAR al termine della compilazione.
Adesso quando tu richiedi una build e una volta completata la distribuzione inizierà automaticamente e non è necessario alcun intervento manuale.
auricolare vr per xbox one x
Conclusione
In questo tutorial, abbiamo imparato come automatizzare la distribuzione di un'applicazione senza intervento manuale utilizzando IBM Urbancode Deploy, uno strumento molto utile per DevOps.
Oggi è molto cruciale anche dal punto di vista dell'automazione. Siamo anche venuti a sapere come il processo IBM Rational Team Concert BUILD può essere esteso per automatizzare la distribuzione una volta completata la compilazione.
Questo tutorial si è concentrato su JBoss come server delle applicazioni. È inoltre possibile utilizzare altri server delle applicazioni J2EE come Websphere Application Server, Weblogic, Tomcat ecc., Nonché per l'automazione della distribuzione.
Fateci sapere i vostri pensieri / suggerimenti nella sezione commenti qui sotto.
Lettura consigliata
- Differenza tra desktop, test server client e test Web
- Installazione dell'applicazione sul dispositivo e avvio del test da Eclipse
- Guida al test di sicurezza delle applicazioni Web
- Processi SQA: come testare un'applicazione completa?
- Come trovare un bug nell'applicazione? Suggerimenti e trucchi
- Java Virtual Machine: come JVM aiuta nell'esecuzione di applicazioni Java
- Come testare l'applicazione per l'assistenza sanitaria - Parte 1
- Tutorial AWS Elastic Beanstalk per la distribuzione di applicazioni Web .NET