Nota:

Questa esercitazione richiede l'accesso a Oracle Cloud. Per iscriversi a un account gratuito, consulta Inizia a utilizzare Oracle Cloud Infrastructure Free Tier.
Utilizza valori di esempio per le credenziali, la tenancy e i compartimenti di Oracle Cloud Infrastructure. Al termine del laboratorio, sostituisci questi valori con quelli specifici del tuo ambiente cloud.

Distribuire Oracle SOA Suite in Oracle Visual Builder Studio

Introduzione

Oracle Visual Builder Studio è lo strumento Oracle ufficiale per automatizzare i processi DevOps con diverse tecnologie come:

Kubernetes/Docker
funzioni
Application Server come Oracle Weblogic, IIS, JBoss, Tomcat
Oracle Forms
Oracle SOA Suite
Oracle Integration (OIC)

Questa esercitazione descrive un esempio di come implementare le seguenti funzionalità in Oracle SOA Suite.

Visualizzazione di un servizio REST
Utilizzo degli argomenti Kafka (o di streaming di Oracle Cloud) tramite un'API REST compatibile con Kafka
Implementare una chiamata Java incorporata
Distribuisci automaticamente il pacchetto SOA Suite nel server SOA

Nota importante: attualmente è possibile implementare CI/CD con Oracle SOA Suite tramite Oracle Visual Builder Studio. Questo perché solo Visual Builder Studio dispone di plugin già preinstallati nella virtual machine per elaborare e compilare (BUILD) i pacchetti necessari. Pertanto, non è ancora possibile implementare CI/CD con altri strumenti di mercato come Jenkins,

Obiettivi

Implementa un progetto in SOA Suite che può essere distribuito automaticamente tramite il processo DevOps con Oracle Visual Builder Studio.

Prerequisiti

Conoscenza dei seguenti elementi:

Concetti e componenti di SOA Suite
Concetti e usi di Kafka
Sviluppo su JDeveloper IDE

Task 1: creare l'istanza di streaming Oracle

Oracle Cloud Streaming è un'applicazione che mira a fungere da coda di messaggi proprio come lo strumento Kafka open source. Oracle Streaming è una soluzione gestita che ti consente di creare un'istanza da usare e di non doversi preoccupare della gestione del controllo dell'infrastruttura. Paghi solo per le risorse che utilizzi. Lo strumento ti consente anche di utilizzare l'API REST di Kafka, rendendola compatibile con i progetti Kafka esistenti con i vantaggi di "cloud as a service".

In questa esercitazione, eseguiamo un'implementazione del servizio SOA da produrre e un altro servizio per utilizzare i dati in una coda di messaggi. Pertanto, la nostra prima tappa sarà il provisioning di un ambiente di streaming Oracle.

Crea un gruppo di utenti per lo streaming e abilita gli utenti in questo gruppo. Una volta eseguita questa operazione, possiamo determinare l'accesso a questo gruppo tramite i criteri. Vedere l'esempio riportato di seguito su come determinare l'accesso per l'uso di Oracle Cloud Streaming.
Creare l'istanza di streaming di Oracle Cloud. Nel menu principale selezionare Analytics & AI, Streaming come mostrato nell'immagine seguente.
Una volta eseguita questa operazione, verrà visualizzata la console con le istanze di Oracle Cloud Streaming. Per creare l'istanza, selezionare il compartimento e fare clic su Crea flusso.
Fornire i dati dell'istanza, ad esempio il nome e il compartimento. Richiedere inoltre la creazione di un nuovo pool di flussi e fornire un nome per il pool. Fare clic su Crea.
Attendere il completamento della creazione del flusso. Il flusso viene creato come mostrato nella seguente immagine.
Recuperare le impostazioni dall'interfaccia API REST compatibile con Kafka facendo clic sul collegamento Configurazioni Kafka Connect, come mostrato nell'immagine riportata di seguito.
Creare la configurazione selezionando il compartimento e facendo clic sull'opzione Crea configurazione di Kafka Connect.
Immettere il compartimento e il nome della configurazione come mostrato nella seguente immagine. Creare la configurazione facendo clic su Crea configurazione di Kafka Connect.
Recupera i parametri di configurazione per connettersi a Oracle Cloud Stream. Passare all'opzione Streams dai collegamenti a sinistra.
Fare clic sul pool creato in precedenza.
Fare clic su Impostazioni connessione Kafka.
Copiare i parametri da utilizzare nel codice Java.

Task 2: Creare il progetto SOA Suite in JDeveloper

Verrà creata un'istanza di streaming di Oracle Cloud per sostituire Kafka. Creare un progetto con i seguenti obiettivi:

Progetto per produrre e utilizzare una coda di streaming come Kafka
Servizio REST per eseguire il test di entrambi i servizi

Il progetto completo è incluso in questa esercitazione. È possibile modificare le impostazioni per compilare, creare package e distribuire nell'istanza di SOA Suite.

Nota: questa esercitazione non include passi dettagliati per implementare i servizi REST. Per ulteriori informazioni, consulta la sezione relativa alle modalità di implementazione e utilizzo dei servizi REST con Oracle SOA Suite.

Scaricare il progetto SOAKafkaProducerApp utilizzando il collegamento seguente: SOAKafkaProducerApp.zip.
- Trovare il file dell'applicazione /SOAKafkaProducerApp/SOAKafkaProducerApp/SOAKafkaProducerApp.jws.
- È possibile visualizzare i progetti in JDeveloper: SOAKafkaProducerPrj e SOAKafkaConsumerPrj

Fare clic sulla struttura dell'applicazione e cercare SOAKakfaConsumerPrj e fare doppio clic su KafkaConsumer come mostrato nell'immagine seguente.

Questa è la visione del progetto SOA per il consumo delle code Kafka. Si tratta di un'implementazione tipica del tipo Composito SOA. Si tratta di un servizio REST (componente presente nella corsia Servizi esposti) che deve essere distribuito sul server SOA. Il componente collegato al servizio è l'implementazione del servizio stesso ed è organizzato nel nuotatore Components come mostrato nell'immagine precedente. Facendo doppio clic sul componente KafkaConsumer si verrà indirizzati all'implementazione del servizio come indicato di seguito:
La prima fase di implementazione inizia con un componente denominato Ricevi, responsabile della ricezione dei parametri di lavoro iniziali, tipici di una chiamata REST. In questa esercitazione non verranno passati parametri, ma viene illustrata qui per i servizi che richiedono questa risorsa.
Il componente Java Embedded è responsabile della chiamata di una routine Java che, in questo caso, chiamerà una classe denominata KafaExample commentata successivamente.

Il codice Java richiamato in questo incorporamento Java è responsabile delle routine di produzione e consumo di Kafka o Oracle Stream (tenere presente che l'API per Oracle Streaming è compatibile con Kakfa).

java
		package soakafka;

		import org.apache.kafka.clients.consumer.ConsumerRecord;
		import org.apache.kafka.clients.consumer.ConsumerRecords;
		import org.apache.kafka.clients.consumer.KafkaConsumer;
		import org.apache.kafka.clients.producer.KafkaProducer;
		import org.apache.kafka.clients.producer.Producer;
		import org.apache.kafka.clients.producer.ProducerRecord;
		import org.apache.kafka.common.serialization.StringSerializer;
		import org.apache.kafka.common.serialization.StringDeserializer;

		import java.util.Arrays;
		import java.util.Date;
		import java.util.Properties;

		import java.util.concurrent.ExecutionException;

		import org.apache.kafka.clients.producer.Callback;
		import org.apache.kafka.common.errors.WakeupException;

		public class KafkaExample {
		    private final String topic;
		    private final Properties props;

		    public KafkaExample(String brokers, String username, String password) {
		        this.topic = "kafka_like";

		        String jaasTemplate = "org.apache.kafka.common.security.scram.ScramLoginModule required username=\"%s\" password=\"%s\";";
		        String jaasCfg = String.format(jaasTemplate, username, password);

		        String serializer = StringSerializer.class.getName();
		        String deserializer = StringDeserializer.class.getName();
		        //Propriedades
		        props = new Properties();
		        props.put("bootstrap.servers", brokers);
		        props.put("group.id", "kafka-hoshikawa");
		        props.put("enable.auto.commit", "false");
		        props.put("max.poll.records", "10");
		        props.put("auto.offset.reset", "earliest");
		        props.put("key.deserializer", deserializer);
		        props.put("value.deserializer", deserializer);
		        props.put("security.protocol", "SASL_SSL");
		        props.put("sasl.mechanism", "PLAIN");
		        props.put("sasl.jaas.config", jaasCfg);
		        //props.put("ssl.client.auth", "requested");
		    }

		    public String consume() {
		        String ret = "";
		        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
		        consumer.subscribe(Arrays.asList(topic));

		        try {
		          while (true) {
		            ConsumerRecords<String, String> records = consumer.poll(100);
		            for (ConsumerRecord<String, String> record : records)
		            {
		              System.out.println(record.offset() + ": " + record.value());
		              ret = ret + record.value();
		            }
		              if (ret != "")
		                break;
		          }
		        } catch (Exception e) {
		          // ignore for shutdown
		        } finally {
		          consumer.commitAsync();
		          consumer.close();
		        }
		        return ret;
		    };

		    public void produce(String message) {
		        Producer<String, String> producer = new KafkaProducer<String, String>(props);
		        ProducerRecord record = new ProducerRecord<String, String>(topic, "msg", message);

		        Callback callback = (data, ex) -> {
		            if (ex != null) {
		                ex.printStackTrace();
		                return;
		            }
		            System.out.println(
		                "Mensagem enviada com sucesso para: " + data.topic() + " | partition " + data.partition() + "| offset " + data.offset() + "| tempo " + data
		                    .timestamp());
		        };
		        try {
		            producer.send(record, callback).get();
		        } catch (ExecutionException | InterruptedException e) {
		        }
		        finally {
		            producer.close();
		        }
		    }

		    public static void main(String[] args) {
		                /*
				String brokers = System.getenv("CLOUDKARAFKA_BROKERS");
				String username = System.getenv("CLOUDKARAFKA_USERNAME");
				String password = System.getenv("CLOUDKARAFKA_PASSWORD");
		                */
		                String brokers = "cell-1.streaming.us-ashburn-1.oci.oraclecloud.com:9092";
		                String username = "hoshikawaoraclecloud/oracleidentitycloudservice/hoshikawa2@hotmail.com/ocid1.streampool.oc1.iad.amaaaxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxkgztajzakb5a";
		                String password = "Wxxxxxxxxxxxxxxxxxxxxxxk";
				KafkaExample c = new KafkaExample(brokers, username, password);
		        c.consume();
		    }
		}

		    public static void main(String[] args) {
		                /*
				String brokers = System.getenv("CLOUDKARAFKA_BROKERS");
				String username = System.getenv("CLOUDKARAFKA_USERNAME");
				String password = System.getenv("CLOUDKARAFKA_PASSWORD");
		                */
		                String brokers = "cell-1.streaming.us-ashburn-1.oci.oraclecloud.com:9092";
		                String username = "hoshikawaoraclecloud/oracleidentitycloudservice/zzzzzzzzz2@zzzzzzil.com/ocid1.streampool.oc1.iad.amaaaxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxkgztajzakb5a";
		                String password = "Wxxxxxxxxxxxxxxxxxxxxxxk";
				KafkaExample c = new KafkaExample(brokers, username, password);
		        c.consume();
		    }
		}

Includi i pacchetti Java nel codice con Maven.
- In questo progetto, abbiamo inserito il codice Java per chiamare l'API di streaming Kafka o Oracle Cloud. Poiché si tratta di codice Java, le inclusioni dei pacchetti sono spesso necessarie per utilizzare i framework. Maven è lo strumento più utilizzato in questi casi e per questo, devi includerlo nel tuo progetto. Con il pulsante destro del mouse, aprire l'opzione sul progetto e selezionare Da galleria come mostrato nell'immagine seguente.
- Selezionare l'opzione Maven POM for Project.
Ora sarai in grado di configurare il tuo pacchetto con i framework necessari.

Crea con Maven.

Fare clic sulle opzioni delle finestre dell'applicazione, quindi su Vista directory per accedere al file /SOA/SCA-INF/pom.xml.
Fare doppio clic sul file pom.xml per aprirlo nell'editor JDeveloper e selezionare la scheda Origine per visualizzare il codice.
In questo modo sarà possibile visualizzare il codice del file pom.xml.

Di seguito è riportata una modifica molto importante al processo DevOps. DEVE includere queste linee per l'automazione.

Nota: il progetto di questa esercitazione è già configurato per supportare l'automazione DevOps, ma per i nuovi progetti seguire questa procedura per automatizzare il processo DevOps. Tra la tag e la tag è possibile includere questo codice, che sarà responsabile dell'assemblaggio del pacchetto software per una successiva distribuzione con **Ant**.

Per l'automazione DevOps, è necessario includere le 3 righe seguenti.

<directory>target</directory>

<outputDirectory>classes</outputDirectory>

<sourceDirectory>src</sourceDirectory>

Il tuo codice completo sarà così:

xml
    pom.xml

    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>

      <groupId>soakafka</groupId>
      <artifactId>kafka</artifactId>
      <version>1.0-SNAPSHOT</version>

      <dependencies>
        <dependency>
          <groupId>org.apache.kafka</groupId>
          <artifactId>kafka-clients</artifactId>
          <version>1.0.0</version>
        </dependency>
      </dependencies>

      <build>

        <!-- For DevOps automation, you need to include the 3 lines below - Cristiano Hoshikawa - 2020-11-28 -->        
        <directory>target</directory>
        <outputDirectory>classes</outputDirectory>
        <sourceDirectory>src</sourceDirectory>

        <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.1</version>
            <configuration>
              <source>1.8</source>
              <target>1.8</target>
            </configuration>
          </plugin>
          <plugin>
            <artifactId>maven-assembly-plugin</artifactId>
            <configuration>
              <archive>
                <manifest>
                  <mainClass>KafkaExample</mainClass>
                </manifest>
              </archive>
              <descriptorRefs>
                <descriptorRef>jar-with-dependencies</descriptorRef>
              </descriptorRefs>
            </configuration>
            <executions>
              <execution>
                <id>make-assembly</id> <!-- this is used for inheritance merges -->
                <phase>package</phase> <!-- bind to the packaging phase -->
                <goals>
                  <goal>single</goal>
                </goals>
              </execution>
            </executions>
          </plugin>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>3.0.2</version>
            <configuration>
              <archive>
                <manifest>
                  <mainClass>KafkaExample</mainClass>
                  <addClasspath>true</addClasspath>
                </manifest>
              </archive>
            </configuration>
          </plugin>
        </plugins>
      </build>  
    </project>

Crea e distribuisci con Ant.

Ant è uno strumento noto sul mercato, sviluppato dal progetto Jakarta, responsabile dell'automazione delle compilazioni, della creazione di pacchetti e della distribuzione delle applicazioni per progetti come Java. Nel processo DevOps, Ant sarà fondamentale per creare il pacchetto SOA Suite e anche per distribuire questo pacchetto sul server remoto di Weblogic SOA Suite.
Per creare il file build.xml con il pulsante destro del mouse, aprire l'opzione sul progetto e selezionare Da galleria come mostrato nell'immagine seguente.
Selezionare l'opzione Ant nel menu a sinistra, quindi fare clic su Crea file da progetto.

Il file build.xml è un file di configurazione molto comune da utilizzare con Ant.

xml
    build.xml

    <?xml version="1.0" encoding="UTF-8" ?>
    <!--Ant buildfile generated by Oracle JDeveloper-->
    <!--Generated Oct 12, 2020 11:35:33 PM-->
    <project xmlns="antlib:org.apache.tools.ant" name="SOAKafkaProducerPrj" default="all" basedir=".">
      <property environment="env" />
      <property file="build.properties"/>
      <path id="library.SOA.Designtime">
        <pathelement location="${install.dir}/soa/plugins/jdeveloper/extensions/oracle.sca.modeler.jar"/>
      </path>
      <path id="library.SOA.Runtime">
        <pathelement location="${install.dir}/soa/soa/modules/oracle.soa.fabric_11.1.1/fabric-runtime.jar"/>
        <pathelement location="${install.dir}/soa/soa/modules/oracle.soa.fabric_11.1.1/tracking-api.jar"/>
        <pathelement location="${install.dir}/soa/soa/modules/oracle.soa.fabric_11.1.1/tracking-core.jar"/>
        <pathelement location="${install.dir}/soa/soa/modules/oracle.soa.fabric_11.1.1/edn.jar"/>
        <pathelement location="${install.dir}/soa/soa/modules/oracle.soa.mgmt_11.1.1/soa-infra-mgmt.jar"/>
        <pathelement location="${oracle.commons}/modules/com.oracle.webservices.fabric-common-api.jar"/>
      </path>
      <path id="library.BPEL.Runtime">
        <pathelement location="${install.dir}/soa/soa/modules/oracle.soa.bpel_11.1.1/orabpel.jar"/>
      </path>
      <path id="library.Mediator.Runtime">
        <pathelement location="${install.dir}/soa/soa/modules/oracle.soa.mediator_11.1.1/mediator_client.jar"/>
      </path>
      <path id="library.MDS.Runtime">
        <pathelement location="${oracle.commons}/modules/oracle.mds/mdsrt.jar"/>
      </path>
      <path id="library.BC4J.Service.Runtime">
        <pathelement location="${oracle.commons}/modules/oracle.adf.model/adfbcsvc.jar"/>
        <pathelement location="${oracle.commons}/modules/oracle.adf.model/adfbcsvc-share.jar"/>
        <pathelement location="${oracle.commons}/modules/commonj.sdo.backward.jar"/>
        <pathelement location="${oracle.commons}/modules/commonj.sdo.jar"/>
        <pathelement location="${oracle.commons}/modules/oracle.toplink/eclipselink.jar"/>
        <pathelement location="${oracle.commons}/modules/com.oracle.webservices.fmw.wsclient-impl.jar"/>
        <pathelement location="${oracle.commons}/modules/com.oracle.webservices.fmw.jrf-ws-api.jar"/>
        <pathelement location="${oracle.commons}/modules/com.oracle.webservices.fmw.web-common-schemas-impl.jar"/>
      </path>
      <path id="classpath">
        <path refid="library.SOA.Designtime"/>
        <path refid="library.SOA.Runtime"/>
        <path refid="library.BPEL.Runtime"/>
        <path refid="library.Mediator.Runtime"/>
        <path refid="library.MDS.Runtime"/>
        <path refid="library.BC4J.Service.Runtime"/>
      </path>
      <target name="init">
        <tstamp/>
        <mkdir dir="${workspace}/SOAKafkaProducerApp/SOAKafkaProducerPrj/SOA/SCA-INF/classes"/>
      </target>
      <target name="all" description="Build the project" depends="deploy,copy"/>
      <target name="clean" description="Clean the project">
        <delete includeemptydirs="true" quiet="true">
          <fileset dir="${output.dir}" includes="**/*"/>
        </delete>
      </target>
      <target name="compile" depends="init">
          <javac
                   srcdir="${workspace}/SOAKafkaProducerApp/SOAKafkaProducerPrj/SOA/SCA-INF/src/soakafka"
                   destdir="${workspace}/SOAKafkaProducerApp/SOAKafkaProducerPrj/SOA/SCA-INF/classes"
               includeantruntime="false">
               <include name="${workspace}/SOAKafkaProducerApp/SOAKafkaProducerPrj/SOA/SCA-INF/lib/**"/>
        </javac>
      </target>
      <target name="sca-compile" depends="compile">
          <ant antfile="${middleware.home}/soa/bin/ant-sca-compile.xml" inheritAll="false">
               <property name="scac.input" value="${workspace}/SOAKafkaProducerApp/SOAKafkaProducerPrj/SOA/composite.xml"/>
          </ant>
      </target>

      <target name="sca-package" depends="sca-compile">
          <ant antfile="/${middleware.home}/soa/bin/ant-sca-package.xml" inheritAll="false">
               <property name="compositeDir" value="${workspace}/SOAKafkaProducerApp/SOAKafkaProducerPrj/SOA"/>
              <property name="compositeName" value="SOAKafkaProducerPrj"/>
              <property name="revision" value="${revision}"/>
              <property name="sca.application.home" value="${workspace}/SOAKafkaProducerApp/SOAKafkaProducerPrj"/>
          </ant>
      </target>

      <target name="deploy" description="Deploy JDeveloper profiles" depends="sca-package">
        <taskdef name="ojdeploy" classname="oracle.jdeveloper.deploy.ant.OJDeployAntTask" uri="oraclelib:OJDeployAntTask"
                 classpath="${oracle.jdeveloper.ant.library}"/>
        <ora:ojdeploy xmlns:ora="oraclelib:OJDeployAntTask" executable="${oracle.jdeveloper.ojdeploy.path}"
                      ora:buildscript="${oracle.jdeveloper.deploy.dir}/ojdeploy-build.xml"
                      ora:statuslog="${oracle.jdeveloper.deploy.dir}/ojdeploy-statuslog.xml">
          <ora:deploy>
            <ora:parameter name="workspace" value="${oracle.jdeveloper.workspace.path}"/>
            <ora:parameter name="project" value="${oracle.jdeveloper.project.name}"/>
            <ora:parameter name="profile" value="${oracle.jdeveloper.deploy.profile.name}"/>
            <ora:parameter name="nocompile" value="false"/>
            <ora:parameter name="outputfile" value="${oracle.jdeveloper.deploy.outputfile}"/>
          </ora:deploy>
        </ora:ojdeploy>

         <!-- Deployment SOA Suite Composite -->
        <ant antfile="/${middleware.home}/soa/bin/ant-sca-deploy.xml" target="deploy" inheritall="false">
          <property name="user"      value="${WEBLOGICUSER}"/>
          <property name="password"  value="${WEBLOGICPWD}"/>
          <property name="serverURL"     value="${WEBLOGICURL}"/>
          <property name="sarLocation"   value="${workspace}/SOAKafkaProducerApp/SOAKafkaProducerPrj/SOA/deploy/sca_SOAKafkaProducerPrj_rev${revision}.jar"/>
          <property name="overwrite"     value="true"/>
        </ant>

      </target>
      <target name="copy" description="Copy files to output directory" depends="init">
        <patternset id="copy.patterns">
          <include name="**/*.GIF"/>
          <include name="**/*.JPEG"/>
          <include name="**/*.JPG"/>
          <include name="**/*.PNG"/>
          <include name="**/*.cpx"/>
          <include name="**/*.dcx"/>
          <include name="**/*.ejx"/>
          <include name="**/*.gif"/>
          <include name="**/*.ini"/>
          <include name="**/*.jpeg"/>
          <include name="**/*.jpg"/>
          <include name="**/*.png"/>
          <include name="**/*.properties"/>
          <include name="**/*.sva"/>
          <include name="**/*.tag"/>
          <include name="**/*.tld"/>
          <include name="**/*.wsdl"/>
          <include name="**/*.xcfg"/>
          <include name="**/*.xlf"/>
          <include name="**/*.xml"/>
          <include name="**/*.xsd"/>
          <include name="**/*.xsl"/>
          <include name="**/*.exm"/>
          <include name="**/*.xml"/>
          <exclude name="build.xml"/>
        </patternset>
        <copy todir="${output.dir}">
          <fileset dir="SOA/SCA-INF/src">
            <patternset refid="copy.patterns"/>
          </fileset>
          <fileset dir=".">
            <patternset refid="copy.patterns"/>
          </fileset>
        </copy>
      </target>
    </project>

Il file build.properties determina le proprietà che verranno utilizzate nel file di configurazione build.xml.

build.properties

oracle.commons=../../../../oracle_common/
install.dir=../../../..
oracle.home=${env.ORACLE_HOME_SOA_12_2_1}
oracle.jdeveloper.workspace.path=${env.WORKSPACE}/SOAKafkaProducerApp/SOAKafkaProducerApp.jws
middleware.home=${env.MIDDLEWARE_HOME_SOA_12_2_1}
workspace=${env.WORKSPACE}
oracle.jdeveloper.ant.library=${env.ORACLE_HOME_SOA_12_2_1}/jdev/lib/ant-jdeveloper.jar
oracle.jdeveloper.deploy.dir=${env.WORKSPACE}/SOAKafkaProducerApp/SOAKafkaProducerPrj/deploy
oracle.jdeveloper.ojdeploy.path=${oracle.home}/jdev/bin/ojdeploy
javac.nowarn=off
oracle.jdeveloper.project.name=SOAKafkaProducerPrj
revision=1.0
oracle.jdeveloper.deploy.outputfile=${env.WORKSPACE}/SOAKafkaProducerApp/SOAKafkaProducerPrj/deploy/sca_${profile.name}_rev{$revision}
output.dir=classes
javac.deprecation=off
oracle.jdeveloper.deploy.profile.name=*
javac.debug=on
WEBLOGICPWD=${env.WEBLOGICPWD}
WEBLOGICURL=${env.WEBLOGICURL}
WEBLOGICUSER=${env.WEBLOGICUSER}

Inizializzare l'ambiente SOA Suite per il test. Aprire innanzitutto la porta firewall dell'ambiente SOA Suite. La porta da rilasciare è il 9092, che rappresenta la porta di streaming Oracle o Kafka.
Abilitare il server SOA incorporato in JDeveloper.
- JDeveloper dispone di un server SOA Suite integrato per attività di sviluppo e test. Si tratta di un server con praticamente tutte le funzionalità necessarie per sviluppare i tuoi servizi SOA. Per utilizzare questo server, è necessario crearlo e attivarlo.
- Per attivare il server, è innanzitutto necessario visualizzare gli Application Server. Per questo motivo, passare all'opzione "Finestra" e selezionare Application Server come mostrato nell'immagine seguente.
- La finestra Application Server verrà visualizzata sul lato sinistro della schermata. Assicurarsi che integratedWeblogicServer sia già stato creato nella finestra. In caso contrario, sarà necessario crearlo e attivarlo per l'uso.
- Andare all'opzione Esegui e selezionare Avvia istanza server come mostrato nell'immagine seguente.
- Immettere i dati necessari per creare l'istanza WebLogic. Prendere nota dei valori necessari in un secondo momento per i test.
- Se il server è stato creato o è già disponibile, fare clic con il pulsante destro del mouse sul server e attivarlo come mostrato nell'immagine seguente.
Esegui una distribuzione manuale in SOA Suite.
- In primo luogo, eseguiamo manualmente la distribuzione del servizio consumer Kafka (SOAKafkaConsumerPrj). A tale scopo, individuare la scheda Applicazioni e aprire le opzioni di menu con il pulsante destro del mouse, come mostrato nell'immagine seguente.
- Selezionare l'opzione Distribuisci, quindi creare un nuovo profilo di distribuzione. Verrà visualizzata una schermata di configurazione ed è necessario scegliere il tipo di profilo come File SOA-SAR in quanto verrà generato un file.
- Questa è la preparazione per consentirci di distribuire il tuo package nel passo successivo. Nella schermata successiva mantenere le opzioni specificate e fare clic su OK.
- Aprire di nuovo l'opzione di menu Distribuisci. L'opzione di distribuzione viene creata e pronta per l'uso. Selezionarlo.
- Ora scegliamo l'opzione per la distribuzione diretta nel tuo server SOA. Quindi scegliere l'opzione come mostrato di seguito.
- Lasciare tutte le opzioni fornite e selezionare Sovrascrivere i composti esistenti con lo stesso ID revisione. Se questa opzione non è selezionata e si tenta di eseguire distribuzioni consecutive dopo la prima esecuzione, si verrà interrotti con un messaggio di errore.
- Selezionare quindi l'opzione IntegratedWeblogicServer. Questa opzione rappresenta il server incorporato di JDeveloper spiegato nella sezione precedente (Come abilitare il server SOA incorporato in JDeveloper).
- Se il server Weblogic JDeveloper è stato creato e avviato correttamente, verrà visualizzata l'opzione riportata di seguito e lo stato "RUNNING" per confermare che tutto è corretto. Se questa opzione non è disponibile, è probabile che il server non sia stato ancora creato o che non sia stato avviato. Esaminare i passi precedenti.
- Confermare con Avanti fino alla schermata di riepilogo e fare clic su Fine.
- Nella finestra in basso al centro è possibile seguire la distribuzione dell'applicazione. Attendere che Distribuzione terminata venga visualizzato come messaggio di operazione riuscita.
Installare il certificato JKS in Weblogic.
- Negli ambienti SSL sarà necessario creare la sicurezza tramite chiavi (pubbliche/private) che verranno eseguite tramite certificati JKS, adatti all'ambiente WebLogic. Il processo di generazione delle chiavi viene eseguito ottenendo il certificato dell'istanza di streaming di Oracle Cloud e aggiungendo questo certificato a un file JKS, che verrà chiamato DemoTrust (DemoTrust.jks).
  
  Nota: il file DemoTrust.jks verrà contrassegnato con un ALIAS e con una password che verrà utilizzata nel codice Java.
- Dopo aver creato il file JKS, è possibile spostarlo nella struttura del server WebLogic.
  1. Ottieni il certificato Oracle Cloud Streaming. Per ulteriori informazioni, vedere Uso dell'adattatore di servizio Oracle Cloud Infrastructure Streaming con Oracle Integration Generation 2.
  2. Generare il file JKS.
  3. Installare il file JKS in Weblogic.
    
    echo -n | openssl s_client -connect cell-1.streaming.us-ashburn-1.oci.oraclecloud.com:9092 | sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p' > ociStreaming.cert keytool -keystore Streaming_truststore.jks -alias OSSStream -import -file ociStreaming.cert
    
    sudo keytool -importcert -file ociStreaming.cert -keystore DemoTrust.jks -alias "kafka" -storepass DemoTrustKeyStorePassPhrase
    
    Ad esempio:
    
    echo -n | openssl s_client -connect cell-1.streaming.us-ashburn-1.oci.oraclecloud.com:9092 | sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p' > ociStreaming.cert keytool -keystore Streaming_truststore.jks -alias OSSStream -import -file ociStreaming.cert
    
    sudo keytool -importcert -file ociStreaming.cert -keystore DemoTrust.jks -alias "kafka" -storepass DemoTrustKeyStorePassPhrase
    - Se si desidera generare o eliminare i keystore in base all'alias, attenersi alla procedura riportata di seguito.
      shell sudo keytool -import -v -file streaming.us-ashburn-1.oci.oraclecloud.com.cer -storepass changeit -keystore /Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre/lib/security/cacerts -alias "kafka" sudo keytool -delete -alias kafka -keystore /Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre/lib/security/cacerts -storepass changeit sudo keytool -import -v -file streaming.us-ashburn-1.oci.oraclecloud.com.cer -keystore DemoTrust.jks -alias "kafka" -storepass DemoTrustKeyStorePassPhrase sudo keytool -delete -alias kafka -keystore DemoTrust.jks -storepass DemoTrustKeyStorePassPhrase
    - Trovare la cartella wlserver che in genere ha questo percorso: /wlserver/server/lib. Ad esempio: cd /u01/app/oracle/middleware/wlserver/server/lib, cd /User/u01/Oracle/Middleware/Oracle_Home/wlserver/server/lib
    - Sostituire il file DemoTrust.jks con quello generato in questo passo.
    - Dopo aver copiato il file DemoTrust.jks, è necessario modificare la directory in cui è stato distribuito il file. Modificare i file /src/soakafka/KafkaExample.java di entrambi i progetti (SOAKafkaProducerprj e SOAKafkaConsumerprj) durante la creazione della classe nel modo seguente:
Eseguire il test dell'applicazione.
- Dopo aver caricato l'ambiente di test, l'istanza sarà disponibile all'indirizzo: http://localhost:7101/em.
- Memorizza nome utente e password.
- Passare all'applicazione sotto la voce di menu SOA e l'opzione Componenti distribuiti.
- Compilare il parametro del messaggio richiesto dal servizio, in base all'implementazione. Questo parametro è stato chiamato "msg" e il formato del messaggio è JSON in base ai passi precedenti.
- Dopo aver immesso il messaggio in formato JSON, fare clic su "Test del servizio Web" per eseguire il servizio producer nella coda dei messaggi.

Task 3: creare un'istanza di SOA Suite in Oracle Cloud

Per distribuire l'applicazione, è necessario disporre di un'istanza attiva di Oracle SOA Suite. L'istanza da utilizzare in questa esercitazione sarà l'immagine disponibile sul nostro Marketplace e avrà una struttura SOA Suite servita da un bastion per proteggere il server.

Per questo motivo, creiamo un'istanza. Nella console di Oracle Cloud fare clic sul menu principale (nell'angolo in alto a sinistra dello schermo), sull'opzione "Marketplace" e "Tutte le applicazioni" come indicato di seguito.
Nella schermata di ricerca delle immagini digitare "soa suite" per trovare l'immagine corretta:
Fare clic sull'opzione "Oracle SOA Suite (BYOL)" per iniziare a creare l'istanza. Verranno visualizzate alcune opzioni obbligatorie da selezionare. Per ulteriori informazioni, consulta l'articolo sull'uso di Oracle SOA Suite su Marketplace in Oracle Cloud Infrastructure.
- Conferma la versione di SOA Suite: 12.2.1.4 o successiva (questo workshop è stato sviluppato con la versione 12.2.1.4).
- Selezionare il compartimento in cui si desidera creare l'istanza di SOA Suite.
- Confermare l'accettazione dei termini e delle condizioni del contratto di licenza.
- Fare clic su Avvia stack.
Dal menu principale della console di Oracle Cloud, andare a Computazione e istanze.
Selezionare il compartimento in cui è stata creata l'istanza di SOA Suite e, quando viene selezionata, verranno visualizzate 2 virtual machine.
- Server SOA Suite
- La VM che fungerà da base per proteggere il server SOA Suite
Nota: il bastion VM avrà un IP pubblico, al quale sarà possibile accedere tramite Internet per accedere al server SOA Suite aprendo un tunnel IP, spiegato in seguito.
Per stabilire un tunnel tra il server Bastion e l'istanza di SOA Suite, è possibile eseguirlo tramite il comando SSH come indicato di seguito.
```
shell
    ssh -Y -i <Arq.Chave SSH> -L <Port SOA>:<IP Instance SOA Suite>:<Port External> opc@<IP Public Bastion>

    Example:
    ssh -Y -i keyrvbastion.pem -L 7002:10.253.128.9:7002 opc@152.67.55.11
```
Dopo aver stabilito la connessione tramite Bastion, è possibile accedere a Weblogic Enterprise Manager con http://localhost:7002/em.

Task 4: Automatizza la distribuzione con Oracle Visual Builder Studio

Ora rendiamo automatica la distribuzione delle implementazioni SOA al server Weblogic creato nel passo precedente. Per questo motivo è necessaria un'istanza di Oracle Visual Builder Studio. Oracle Visual Builder Studio funziona in base ai progetti, in modo da poter creare un progetto e includere gli utenti che prenderanno parte alla sua esecuzione.

Per ulteriori informazioni sull'operazione, vedere la sezione Collegamenti correlati alla fine di questo documento, cercare Distribuisci con Visual Builder Studio. Successivamente, seguire la procedura per configurare la creazione e la distribuzione automatizzate delle implementazioni SOA Suite nel server Weblogic.

Configurare una virtual machine per BUILD in ORACLE SOA Suite. Prima di avviare le impostazioni, sarà necessario configurare una virtual machine che soddisfi le esigenze di compilazione di un progetto Oracle SOA Suite, per questo motivo sarà necessario selezionare gli strumenti corretti da installare in questa VM.
1. Fare clic su Organizzazione nel menu a sinistra, quindi su Modelli Virtual Machine.
2. Fare clic su Crea modello per configurare gli strumenti disponibili per la creazione dei progetti SOA Suite. Quindi digitare un nome per il modello e, se lo si desidera, è possibile descrivere il modello. Non dimenticare di selezionare la piattaforma su cui sarà attiva questa VM. Scegli l'opzione Oracle Linux (fino alla data di questo documento avevamo Oracle Linux 7, ma puoi selezionare un'altra opzione più recente.
3. Selezionare tutti i componenti importanti per la creazione dei progetti. Scegliere tutte le opzioni come indicato di seguito.
  
  Il TEMPLATE è stato creato e l'istanza della VM verrà creata non appena un progetto richiederà una build.
4. CREA la configurazione di un progetto in Oracle Visual Builder Studio. Aprire innanzitutto un progetto in Oracle Visual Builder Studio, nell'esempio riportato di seguito, fare clic su CRISTIANO HOSHIKAWA PROJ.
  - Verrà visualizzata la pagina del progetto, insieme a un menu a sinistra con le opzioni disponibili e a destra i progetti nel repository di codici sorgente e anche il team che fa parte di questo progetto (utenti del progetto).
5. Fare clic sull'opzione CREAZIONE dal menu a sinistra per visualizzare tutte le impostazioni esistenti e configurare una nuova CREAZIONE per il progetto. Fare clic su Crea job.
6. Immettere un nome per il job e selezionare anche il modello VM (creato nella sessione precedente).
Ora configuriamo la build del tuo progetto passo dopo passo. La prima parte della configurazione sarà quella di stabilire il repository del progetto Oracle SOA Suite che deve essere creato in precedenza con il codice sorgente. In questo documento, stiamo lavorando con il progetto SOAKafkaProducerApp disponibile in git di questo documento. Sarà possibile duplicare questo progetto all'istanza di Oracle Visual Builder Studio.
1. Dopo aver clonato il progetto SOAKafkaProducerApp in Visual Builder Studio, configurare il documento BUILD con il nome del repository git e selezionare l'opzione "Eseguire automaticamente la build al commit SCM". Controllare inoltre che il nome della diramazione corrisponda al progetto Git.
2. Selezionare la scheda "Parametri". Sarà necessario creare 3 parametri con il menu Casella combinata "Aggiungi parametri" sul lato destro. Di seguito, i nomi che devono essere creati e anche tra parentesi, il tipo:
  - WEBLOGICUSER: l'utente Weblogic (tipo di stringa)
  - WEBLOGICPWD: password utente Weblogic (tipo Segreto/Password)
  - WEBLOGICURL: l'URL dell'istanza di Weblogic (tipo stringa)
  - Un'osservazione importante è che l'URL in WEBLOGICURL deve essere localhost come tunnel sarà stabilito attraverso il Bastion Server
3. Fare clic sulla scheda "Prima della build" per configurare il tunnel SSH dal server Bastion al server Weblogic SOA Suite. Ricordarsi di avere la chiave SSH (chiave privata) e compilare il campo corrispondente. Compilare i dati per l'assieme tunnel.
  - Nome utente: opc
  - Porta locale: 11002
  - Host remoto: IP privato dell'istanza di SOA Suite
  - Porta remota: 11002
  - Server SSH: IP pubblico del bastion
  - Un'osservazione importante è che la porta 11002 è stata configurata in precedenza in modo che sia esattamente la porta di accesso per la distribuzione dei progetti SOA Suite.
4. Fare clic sulla scheda "Passi" per configurare BUILD (tramite Maven) e DEPLOYMENT (tramite ANT) del progetto SOA Suite. Compilare come indicato di seguito.
  - MAVEN
  - Obiettivi: compilare il package
  - File POM: SOAKafkaProducerApp/SOAKafkaConsumerPrj/SOA/SCA-INF/pom.xml. Questo è il file pom.xml di Maven per l'assemblaggio del package di progetto
  - ANT
    - Destinazioni: distribuzione del pacchetto scala
    - File build: SOAKafkaProducerApp/SOAKafkaConsumerPrj/build.xml. Questo è il file Ant build.xml per la distribuzione dell'applicazione dopo la creazione.
  - Proprietà
    - WEBLOGICUSER=${WEBLOGICUSER}
    - WEBLOGICPWD=${WEBLOGICPWD}
    - WEBLOGICURL=${WEBLOGICURL}
  Nota importante:
  - L'applicazione SOAKafkaProducerApp dispone di 2 progetti: SOAKafkaProducerPrj e SOAKafkaConsumerPrj.
  - Stiamo illustrando la configurazione di uno dei progetti. È necessario eseguire gli stessi passi per l'altro progetto.
5. Ora completiamo la configurazione BUILD. Selezionare la scheda "Dopo la creazione". Questo passo è facoltativo, tuttavia è possibile generare l'artifact creato dal passo precedente durante l'esecuzione di Maven. Configurare questo passo in modo che l'artifact venga generato per il successivo download.
Esegui BUILD in Oracle Visual Builder Studio. Una volta configurato, ogni volta che viene eseguito un commit nel repository di codice (Visual Builder Studio git), il comando BUILD verrà avviato automaticamente. È inoltre possibile eseguire l'operazione CREAZIONE manualmente, poiché è sufficiente fare clic sull'opzione CREAZIONE. Provare a eseguire BUILD e sarà possibile controllare i log generati.

Approvazioni

Autore - Cristiano Hoshikawa (Oracle LAD A-Team Solution Engineer)

Altre risorse di apprendimento

Esplora altri laboratori su docs.oracle.com/learn o accedi a contenuti di formazione gratuiti sul canale YouTube di Oracle Learning. Inoltre, visitare education.oracle.com/learning-explorer per diventare Explorer di Oracle Learning.

Per la documentazione sul prodotto, visitare il sito Oracle Help Center.

Titolo e informazioni sul copyright

Deploy Oracle SOA Suite in Oracle Visual Builder Studio

F79404-01

March 2023