Weblogic Scripting tool. Creando un dominio - Parte 3.

Por Isaac Ruiz.
Publicado en Abril 2018

Revisado por Robby N. Vega


Indice de Contenidos


Alcance.
Requerimientos.
Introducción.
Validación del dominio.
Nociones preliminares.
    Invocar Shell
    Current Managemend Object. CMO.
Comandos a utilizar.
    Activando el shell nuevamente.
    Templates disponibles.
    showAvailableTemplates.
    selectTemplate.
    loadTemplates.
    Set.
    setOption.
    writeDomain.
startWeblogic.
Validación.
Conclusión.
Enlaces.



Alcance.


El presente documento muestra los comandos necesarios para crear un dominio de WLS12c, utilizando WLST. Este dominio se crea utilizando los templates disponibles y eligiendo uno en particular.

Este documento está basado en el contenido de estos dos documentos, los cuales forman parte de la documentación de Oracle Fusion Middleware 12c:

Como preámbulo se muestra el concepto y utilidad del Current Managemend Object: cmo.




Requerimientos.


El presente documento asume que se tiene cierta experiencia construyendo aplicaciones usando el lenguaje de programación java y/o python, asume también que el lector tiene experiencia como desarrollador de aplicaciones y conoce en ese nivel un sistema operativo, por ende, sabe ejecutar tareas a nivel CLI.

El documento también asume que se tiene experiencia creando dominios con WLS en alguna de sus versiones más recientes. Los ejercicios asumen que tenemos disponible un dominio WLS con su respectivo ORACLE_HOME, esto para acceder al ejecutable: wlst.sh/wlst.cmd

El dominio existente se requiere para introducir el concepto de cmo.

Si quieres ver información sobre cómo crear dominios puedes revisar alguno de estos artículos:




Introducción.


En el artículo anterior, comenzamos a conocer como pasar parámetros a nuestros scripts. Este era un requerimiento necesario para poder llegar a scripts más interesantes.

La primera tarea cuando comenzamos a trabajar con WLST es crear un dominio, por ello, ese será el primer script con el que continuaremos esta serie.

Si has instalado un dominio de WLS seguramente sabes que el asistente (Configuration Wizard) que trae es muy amigable y la creación del dominio no es complicada, el tema es que en ocasiones queremos automatizar la instalación o simplemente agilizarla. En ese tipo de escenarios WLST es de gran utilidad.

Manos a la obra.




Validación del dominio.


Requerimos un dominio existente para introducir el concepto de cmo, para ello primero vamos a validar que este dominio esté respondiendo adecuadamente y que tenemos a la mano la ruta de nuestro ORACLE_HOME.

Para este ejemplo asumiremos que tenemos los siguientes valores

Url de la consola de administración:

http://localhost:7001/console/

Usuario:

Weblogic

Puerto:

welcome1

Servidor:

AdminServer

ORACLE_HOME:

/Users/user1/Oracle/Middleware/Oracle_Home/





Figura 1. WLS 12c. Pantalla de login.
Nos autenticamos para validar los valores que tenemos, debemos ver nuestra consola web.




Figura 2. WLS 12c. Consola web.

Con esto los datos del dominio que tenemos están validados.




Nociones preliminares.


Con el dominio funcionando vamos a activar el shell para conocer más sobre el cmo.

Invocar Shell

Regresamos a nuestra tabla de valores para ubicar el valor de nuestro ORACLE_HOME.

Vamos a invocarlo, el invocador del Shell se encuentra en la siguiente ruta:

$ORACLE_HOME\oracle_common\common\bin\wlst.sh



$ORACLE_HOME\oracle_common\common\bin\wlst.cmd

Si usas Windows.


A lo largo de este documento asumiremos que estamos ejecutando los ejemplos en una maquina Linux:

%>./wlst.sh
Initializing WebLogic Scripting Tool (WLST) ...
Welcome to WebLogic Server Administration Scripting Shell
Type help() for help on available commands    


Listo, tenemos nuestro shell en modo offline.



Current Managemend Object. CMO.

CMO, son las siglas de Current Managemend Object, algo así como Objeto de administración actual.

Es una variable que WLST ofrece y representa la entidad administrable sobre la que estamos trabajando.

Una vez que ya estamos en modo online, veamos un poco más de que trata.


CMO en modo offline.

Continuando en modo offline, escribamos cmo y veamos el resultado:

wls:/offline> cmo
wls:/offline>


Sólo se imprime una línea en blanco, eso se debe a que estamos en modo offline y en consecuencia no hay nada que podamos “administrar”.


CMO en modo online.

Vamos a conectarnos utilizando los valores que ya tenemos validados, puedes ver la 1ª parte de esta serie si tienes duda sobre el comando connect.

wls:/offline> connect('weblogic','welcome1','t3://localhost:7001')
Connecting to t3://localhost:7001 with userid weblogic ...
Successfully connected to Admin Server "AdminServer" that belongs to domain "base_domain".

Warning: An insecure protocol was used to connect to the server. 
To ensure on-the-wire security, the SSL port or Admin port should be used instead.

wls:/base_domain/serverConfig/>


Listo, estamos conectados.

Vamos a volver a dar de entrada: cmo.

wls:/base_domain/serverConfig/> cmo
[MBeanServerInvocationHandler]com.bea:Name=base_domain,Type=Domain
wls:/base_domain/serverConfig/>


Y a diferencia de la ejecución anterior, el shell ahora nos indica que tenemos ya un cmo activo.

¿Reconoces el formato del texto que se muestra? Efectivamente, cada cmo tras bambalinas apunta a un MBean. Así que, en realidad estamos accediendo a la jerarquía de MBeans de nuestro dominio.


Navegación

Algo que debemos saber ahora es que, una vez que estamos en modo online, podemos navegar de manera jerárquica dentro de nuestro dominio; esta navegación se realiza como si se tratara de un sistema de archivos.

WLST eligió una sintaxis similar a la de comandos en unix/linux para su navegación.

Por ejemplo, en linux podemos ver el contenido de la carpeta actual con el comando: ls, con WLST será: ls()

Veamos un ejemplo de salida al invocar ls():

wls:/base_domain/serverConfig/> ls()
dr--   AdminConsole
dr--   AppDeployments
dr--   BatchConfig
dr--   BridgeDestinations
dr--   CdiContainer
dr--   Clusters
dr--   CoherenceClusterSystemResources
dr--   CoherenceManagementClusters
dr--   CoherenceServers
dr--   ConfigurationProperties
dr--   CustomResources
dr--   DebugPatches
dr--   DeploymentConfiguration
dr--   Deployments
dr--   EmbeddedLDAP
dr--   ErrorHandlings
dr--   FileStores
dr--   ForeignJNDIProviders
dr--   Interceptors
dr--   InternalAppDeployments
dr--   InternalLibraries
dr--   JDBCStores
dr--   JDBCSystemResources
dr--   JMSBridgeDestinations
dr--   JMSInteropModules
dr--   JMSServers
dr--   JMSSystemResources
dr--   JMX
dr--   JPA
dr--   JTA
dr--   JoltConnectionPools
dr--   Libraries
dr--   LifecycleManagerConfig
dr--   Log
dr--   LogFilters
dr--   Machines
dr--   MailSessions
dr--   ManagedExecutorServiceTemplates
dr--   ManagedExecutorServices
dr--   ManagedScheduledExecutorServiceTemplates
dr--   ManagedScheduledExecutorServices
dr--   ManagedThreadFactories
dr--   ManagedThreadFactoryTemplates
dr--   MessagingBridges
dr--   MigratableTargets
dr--   OptionalFeatureDeployment
dr--   OsgiFrameworks
dr--   PartitionWorkManagers
dr--   Partitions
dr--   RemoteSAFContexts
dr--   ReplicatedStores
dr--   ResourceGroupTemplates
dr--   ResourceGroups
dr--   ResourceManagement
dr--   RestfulManagementServices
dr--   SAFAgents
dr--   SNMPAgent
dr--   SNMPAgentDeployments
dr--   SecurityConfiguration
dr--   SelfTuning
dr--   ServerTemplates
dr--   Servers
dr--   ShutdownClasses
dr--   SingletonServices
dr--   StartupClasses
dr--   SystemComponentConfigurations
dr--   SystemComponents
dr--   SystemResources
dr--   Targets
dr--   VirtualHosts
dr--   VirtualTargets
dr--   WLDFSystemResources
dr--   WSReliableDeliveryPolicies
dr--   WTCServers
dr--   WebAppContainer
dr--   WebserviceSecurities
dr--   WebserviceTestpage
dr--   XMLEntityCaches
dr--   XMLRegistries

-r--   AdminServerName                              AdminServer
-r--   AdministrationMBeanAuditingEnabled           false
-r--   AdministrationPort                           9002
-r--   AdministrationPortEnabled                    false
-r--   AdministrationProtocol                       t3s
-r--   ArchiveConfigurationCount                    0
-r--   BatchJobsDataSourceJndiName                  null
-r--   BatchJobsExecutorServiceName                 null
-r--   ClusterConstraintsEnabled                    false
-r--   ConfigBackupEnabled                          false
-r--   ConfigurationAuditType                       none
-r--   ConfigurationVersion                         12.2.1.0.0
-r--   ConsoleContextPath                           console
-r--   ConsoleEnabled                               true
-r--   ConsoleExtensionDirectory                    console-ext
-r--   DiagnosticContextCompatibilityModeEnabled    true
-r--   DomainVersion                                12.2.1.0.0
-r--   DynamicallyCreated                           false
-r--   EnableEECompliantClassloadingForEmbeddedAdapters true
-r--   ExalogicOptimizationsEnabled                 false
-r--   GuardianEnabled                              false
-r--   Id                                           0
-r--   InternalAppsDeployOnDemandEnabled            true
-r--   JavaServiceConsoleEnabled                    false
-r--   JavaServiceEnabled                           false
-r--   LastModificationTime                         0
-r--   LogFormatCompatibilityEnabled                false
-r--   MaxConcurrentLongRunningRequests             50
-r--   MaxConcurrentNewThreads                      50
-r--   Name                                         base_domain
-r--   Notes                                        null
-r--   ParallelDeployApplicationModules             false
-r--   ParallelDeployApplications                   true
-r--   Parent                                       null
-r--   ProductionModeEnabled                        false
-r--   RootDirectory                                /…/…/base_domain
-r--   ServerMigrationHistorySize                   -1
-r--   ServiceMigrationHistorySize                  -1
-r--   SiteName                                     null
-r--   Tags                                         null
-r--   Type                                         Domain

-r-x   arePartitionsPresent                         Boolean : 
-r-x   findConfigBeansWithTags                      WebLogicMBean[] : String(type),
                                                    Boolean(matchAll),String[](tags)
-r-x   findConfigBeansWithTags                      WebLogicMBean[] : String(type),
                                                    String[](tags)
-r-x   findPartitionByID                            WebLogicMBean : String(id)
-r-x   freezeCurrentValue                           Void : String(attributeName)
-r-x   getInheritedProperties                       String[] : String[](propertyNames)
-r-x   isInherited                                  Boolean : String(propertyName)
-r-x   isSet                                        Boolean : String(propertyName)
-r-x   listTags                                     String[] : String(type)
-r-x   unSet                                        Void : String(propertyName)

wls:/base_domain/serverConfig/>


Si estás familiarizado con sistemas Linux, seguramente ya reconoces los 3 tipos de valores que se enlistan: carpetas, archivos y ejecutables. Las “carpetas” son objetos que  descienden en la jerarquía dentro del server a partir de la ubicación actual, los “archivos” son las propiedades del cmo actual y los “ejecutables” son los  funciones disponibles del cmo actual, sencillo ¿No crees?

Vamos a probar la función arePartitionsPresent, es el 1er “ejecutable” que aparece en el listado anterior; en python toda invocación de una función debe terminar en ():

wls:/base_domain/serverConfig/> cmo.arePartitionsPresent()
1


La función nos devuelve 1 indicándonos que nuestro dominio sí tiene particiones.

En el caso de las propiedades, para acceder a alguna de ellas requerimos por convención usar el prefijo get  o  is  si se trata de una propiedad de tipo booleano.

Veamos un par de ejemplos, tenemos la propiedad Name que almacena un string, para recuperarla usaremos getName, y tenemos la propiedad ProductionModeEnabled, según vemos devuelve un booleano, así que usaremos el prefijo: is.

Veamos el resultado de ejecutarlas:

wls:/base_domain/serverConfig/> cmo.getName()
'base_domain'
wls:/base_domain/serverConfig/> cmo.isProductionModeEnabled()
0
wls:/base_domain/serverConfig/>


La variable cmo entonces es quien nos permite acceder tanto a propiedades como funciones disponibles según la posición en donde nos encontremos dentro de la jerarquía de nuestro dominio.


En el caso de las carpetas, tenemos también un comando cd.

Si vemos nuevamente el listado anterior, veremos que tenemos una carpeta llamada: Servers.

En WLST cd también es una función, así que la manera de usarla es pasando como parámetro la carpeta a la que queremos acceder.

wls:/base_domain/serverConfig/>cd('Servers')
wls:/base_domain/serverConfig/Servers>      


Toma en cuenta que, al igual que sistemas Linux, las carpetas son sensibles a mayúsculas y minúsculas; Observa también que el prompt ha cambiado y ahora es: wls:/base_domain/serverConfig/Servers, eso nos ayuda a saber siempre en que cmo estamos.

Vamos a ver que hay en ella:

wls:/base_domain/serverConfig/Servers> ls()
dr--   AdminServer


Tenemos a nuestro AdminServer, si tu dominio tiene más servidores, aquí se deben mostrar.

Accedemos al AdminServer:

wls:/base_domain/serverConfig/Servers> cd('AdminServer')


Y ahora recuperaremos dos propiedades:

wls:/base_domain/serverConfig/Servers/AdminServer> cmo.getName()
'AdminServer'
wls:/base_domain/serverConfig/Servers/AdminServer> cmo.getListenAddress()
'localhost'
wls:/base_domain/serverConfig/Servers/AdminServer>


Veamos que otras propiedades tiene este cmo (sólo se muestra un fragmento del listado):

wls:/base_domain/serverConfig/Servers/AdminServer> ls()
dr--   COM
dr--   CandidateMachines
dr--   Cluster
dr--   WebServer
dr--   WebService
dr--   XMLEntityCache
dr--   XMLRegistry

-r--   AcceptBacklog                                300
-r--   AddWorkManagerThreadsByCpuCount              false
-r--   AdminReconnectIntervalSeconds                10
-r--   AdministrationPort                           9002
-r--   AdministrationProtocol                       t3s
-r--   AllowShrinkingPriorityRequestQueue           true
-r--   AutoKillIfFailed                             false
-r--   AutoMigrationEnabled                         false
-r--   JavaCompiler                                 javac
-r--   JavaCompilerPostClassPath                    null
-r--   JavaCompilerPreClassPath                     null
-r--   KeyStores                                    DemoIdentityAndDemoTrust
-r--   ListenAddress                                localhost
-r--   ListenDelaySecs                              0
-r--   ListenPort                                   7001
-r--   ListenPortEnabled                            true
-r--   ListenThreadStartDelaySecs                   60
-r--   MuxerClass                                   weblogic.socket.NIOSocketMuxer
-r--   NMSocketCreateTimeoutInMillis                180000
-r--   Name                                         AdminServer
-r--   NativeIOEnabled                              true
-r--   Notes                                        null
-r--   NumOfRetriesBeforeMSIMode                    3
-r--   OutboundEnabled                              false
-r--   OutboundPrivateKeyEnabled                    false
-r--   PeriodLength                                 60000
-r--   PreferredSecondaryGroup                      null
-r--   PrintStackTraceInProduction                  false
-r--   ReliableDeliveryPolicy                       null
-r--   StagingDirectoryName                         //AdminServer/stage
-r--   StagingMode                                  nostage
-r--   StartupMode                                  RUNNING
-r--   StartupTimeout                               0
-r--   StuckThreadMaxTime                           600
-r--   StuckThreadTimerInterval                     60
-r--   SystemPasswordEncrypted                      ******
-r--   TGIOPEnabled                                 true
-r--   Tags                                         null
-r--   ThreadPoolPercentSocketReaders               33
-r--   TransactionLogFilePrefix                     ./
-r--   TransactionLogFileWritePolicy                Direct-Write
-r--   TunnelingClientPingSecs                      45
-r--   TunnelingClientTimeoutSecs                   40
-r--   TunnelingEnabled                             false
-r--   Type                                         Server
-r--   UploadDirectoryName                          ./servers/AdminServer/upload
-r--   Use81StyleExecuteQueues                      false
-r--   UseConcurrentQueueForRequestManager          false
-r--   UseDetailedThreadName                        false
-r--   VirtualMachineName                           base_domain_AdminServer
-r--   WeblogicPluginEnabled                        false
-r--   XMLEntityCache                               null
-r--   XMLRegistry                                  null

-r-x   freezeCurrentValue                           Void : String(attributeName)
-r-x   getInheritedProperties                       String[] : String[](propertyNames)
-r-x   isInherited                                  Boolean : String(propertyName)
-r-x   isSet                                        Boolean : String(propertyName)
-r-x   synchronousKill                              String : 
-r-x   synchronousStart                             String : 
-r-x   unSet                                        Void : String(propertyName)


Puedes seguir navegando por la jerarquía del dominio o probar con otras propiedades o funciones.

Como has podido observar, cmo es una variable que tenemos disponible para poder acceder a propiedades y funciones dentro de la jerarquía de nuestro dominio.

Estas propiedades y funciones no son más que las que expone el MBean que representa el cmo.




Comandos a utilizar.


Ya estamos más cerca de crear un dominio con WLST, ahora solo nos falta conocer los comandos que utilizaremos en nuestro script.


Activando el shell nuevamente.

Vamos a activar el shell de WLST, lo usaremos en modo offline.

%>./wlst.sh

Initializing WebLogic Scripting Tool (WLST) ...

Welcome to WebLogic Server Administration Scripting Shell

Type help() for help on available commands

wls:/offline>    


Y vamos a dar un ls(),  veamos que muestra:

wls:/offline> ls()
Error: No se ha leído ningún dominio ni ninguna plantilla de dominio.


No hay nada que mostrar ya que estamos en modo offline.


Templates disponibles.

Cuando creas un dominio utilizando el asistente, el configuration wizard, una de las primeras pantallas te pregunta cuál será el template o los templates que va a requerir tu dominio.

En esta pantalla, se eligen los templates en función de lo que queramos agregar a nuestro dominio, el template mínimo es el “Basic Weblogic Server Domain”.

Recordemos esa pantalla:


Figura 3. Configuration Wizard. Selección del template.


Cuando creamos un dominio con WLST el proceso no es distinto, debemos indicar cuál o cuáles serán los templates que vamos a requerir para nuestro dominio.

Así que, lo primero que necesitamos saber es: ¿Cuáles son los templates que tenemos disponibles?

Y, eso es justo lo que el comando showAvailableTemplates realiza.



showAvailableTemplates.

El comando showAvailableTemplates nos muestra un listado de templates disponibles dado el ORACLE_HOME que tenemos configurado.

Veamos que dice la ayuda:

wls:/offline> help('showAvailableTemplates')

Description:


 Display all currently available templates for loading.

Syntax:

showAvailableTemplates(showHidden, verbose, includeApplied)
 showHidden : This flag is optional. This will display hidden templates. 
 The default value is false.
 verbose : This flag is optional. This will display the complete template location path. 
 The default value is false.
 includeApplied : This flag is optional. This will display applied templates. 
 The default value is false.

Example:

wls:/offline> showAvailableTemplates('false','true','false')    


Vamos a invocarlo usando el ejemplo que nos proporciona la ayuda:

wls:/offline> showAvailableTemplates('false','true','false')
'20849: Plantillas disponibles.
20849:Plantillas disponibles actualmente para cargar:
Oracle Enterprise Manager:12.2.1  [/Users/user1/Oracle/Middleware/Oracle_Home/
em/common/templates/wls/oracle.em_wls_template.jar]

Oracle User Messaging Service Basic:12.2.1  [/Users/user1/Oracle/Middleware/Oracle_Home/
oracle_common/common/templates/wls/oracle.ums.basic_template.jar]

Oracle WSM Policy Manager:12.2.1.0  [/Users/user1/Oracle/Middleware/Oracle_Home/
oracle_common/common/templates/wls/oracle.wsmpm_template.jar]

Oracle RAS Session Service:12.2.1.0  [/Users/user1/Oracle/Middleware/Oracle_Home/
oracle_common/common/templates/wls/oracle.ras_template.jar]

Oracle JRF SOAP/JMS Web Services:12.2.1  [/Users/user1/Oracle/Middleware/Oracle_Home/
oracle_common/common/templates/wls/oracle.jrf.ws.soapjms_template.jar]

Oracle Enterprise Manager-Restricted JRF:12.2.1  [/Users/user1/Oracle/Middleware/
Oracle_Home/em/common/templates/wls/oracle.em_wls_restricted_template.jar]

Oracle JRF:12.2.1  [/Users/user1/Oracle/Middleware/Oracle_Home/oracle_common/common/
templates/wls/oracle.jrf_template.jar]

Oracle Restricted JRF:12.2.1  [/Users/user1/Oracle/Middleware/Oracle_Home/
oracle_common/common/templates/wls/oracle.jrf_restricted_template.jar]

WebLogic Coherence Cluster Extension:12.2.1  [/Users/user1/Oracle/Middleware/
Oracle_Home/wlserver/common/templates/wls/wls_coherence_template.jar]

WebLogic Advanced Web Services for JAX-WS Extension:12.2.1  [/Users/user1/Oracle/Middleware/
Oracle_Home/oracle_common/common/templates/wls/oracle.wls-webservice-jaxws-template.jar]

Basic WebLogic Server Domain:12.2.1  [/Users/user1/Oracle/Middleware/Oracle_Home/
wlserver/common/templates/wls/wls.jar]

Oracle OPSS REST Service Application:12.2.1.0  [/Users/user1/Oracle/Middleware/Oracle_Home/
oracle_common/common/templates/wls/oracle.opss.rest_service_template.jar]

WebLogic Advanced Web Services for JAX-RPC Extension:12.2.1  [/Users/user1/Oracle/Middleware/
Oracle_Home/oracle_common/common/templates/wls/oracle.wls-webservice-template.jar]

WebLogic JAX-WS SOAP/JMS Extension:12.2.1  [/Users/user1/Oracle/Middleware/Oracle_Home/
oracle_common/common/templates/wls/oracle.wls-webservice-soapjms-template.jar]
20849: No es necesaria ninguna acci\xF3n.'


Nos aparece un listado de templates disponibles, cada template muestra su información de la siguiente manera:

  Nombre_del_template:versión_del_template [Ubicación_del_template]


Por ejemplo, tenemos el template para un Basic Weblogic Server Domain en la versión 12.2.1 y se encuentra en:

  /Users/user1/Oracle/Middleware/Oracle_Home/wlserver/common/templates/wls/wls.jar 


El listado de templates puede variar según el ORACLE_HOME que tengamos.

De todos los templates desplegados, tomaremos los siguientes:

  • Basic WebLogic Server Domain:12.2.1
  • Oracle Enterprise Manager-Restricted JRF:12.2.1

Hemos seleccionado esos 2 templates para poder crear un dominio con soporte a multitenant y con enterprise manager disponible.

Tenemos ya el nombre y versión de cada template, ahora debemos seleccionarlos.

Eso lo hacemos con el comando selectTemplate.



selectTemplate.

Con selectTemplate vamos a indicar cual o cuales son los templates que vamos a requerir para nuestro dominio.

Veamos que dice la ayuda:

wls:/offline> help('selectTemplate')

Description:


 Selects an existing domain template or application template for domain creation.

Syntax:

selectTemplate(templateName, templateVersion)
- templateName: Template name is required. This should be an exact template name 
defined in template descriptor (template-info.xml).
 templateVersion: Template Version is optional.

Example:

wls:/offline> selectTemplate('Template Name','Template Version')
wls:/offline/base_domain>    


Vamos a seleccionar entonces los dos templates que hemos indicado.

wls:/offline> selectTemplate("Basic WebLogic Server Domain", "12.2.1")
wls:/offline> selectTemplate("Oracle Enterprise Manager-Restricted JRF", "12.2.1")
wls:/offline/>    


Ya que hemos seleccionados los templates que requerimos, el siguiente paso es “cargarlos” para poder ajustarlo y finalmente crear el dominio.

¿Qué significa cargarlos?

Dado que aquí no es un modo gráfico para poder editar los valores que queremos ajustar a nuestro dominio, debemos usar otra forma de interactuar con la información.

Una forma de ver esta operación es que vamos a expandir uno a uno los templates  en nuestro shell para poder realizar configuraciones extras antes de crear realmente el dominio. Entenderemos por crear realmente el dominio a la operación de escribirlo a disco y ponerlo disponible para ser utilizado.

Imagina que cada template es un zip y lo vamos a descomprimir en la carpeta actual para poder modificar cosas para que al terminar podamos escribir todo en otra ruta física.

Vamos por partes para entenderlo, para cargar los templates tenemos el comando: loadTemplates.



loadTemplates.

Veamos que dice la ayuda sobre loadTemplates:

wls:/offline/>help('loadTemplates')

Description:


 Loads all the selected templates using select template.

Syntax:

loadTemplates()
Example:

wls:/offline> loadTemplates()    


Vamos a ejecutarlo:

wls:/offline/>loadTemplates()


Ahora escribe ls() y veras que tenemos resultados.  Esto significa que los templates están cargados.

wls:/offline/>ls()
drw-   AppDeployment
drw-   CoherenceClusterSystemResource
drw-   Credential
drw-   Keystore
drw-   Library
drw-   NMProperties
drw-   Security
drw-   SecurityConfiguration
drw-   Server
drw-   ShutdownClass
drw-   StartupClass
drw-   StartupGroupConfig
drw-   WLDFSystemResource

-rw-   Active                                        false
-rw-   AdminServerName                               AdminServer
-rw-   AdministrationMBeanAuditingEnabled            false
-rw-   AdministrationPort                            9002
-rw-   AdministrationPortEnabled                     false
-rw-   AdministrationProtocol                        t3s
-rw-   AutoDeployForSubmodulesEnabled                true
-rw-   BatchJobsDataSourceJndiName                   null
-rw-   BatchJobsExecutorServiceName                  null
-rw-   ClusterConstraintsEnabled                     false
-rw-   ConfigBackupEnabled                           false
-rw-   ConfigurationAuditType                        null
-rw-   ConfigurationVersion                          12.2.1.0.0
-rw-   ConsoleContextPath                            console
-rw-   ConsoleEnabled                                true
-rw-   ConsoleExtensionDirectory                     console-ext
-rw-   DiagnosticContextCompatibilityModeEnabled     true
-rw-   DomainVersion                                 12.2.1.0.0
-rw-   EnableEeCompliantClassloadingForEmbeddedAdaptersfalse
-rw-   ExalogicOptimizationsEnabled                  false
-rw-   GuardianEnabled                               false
-rw-   Id                                            0
-rw-   InternalAppsDeployOnDemandEnabled             true
-rw-   JavaServiceConsoleEnabled                     false
-rw-   JavaServiceEnabled                            false
-rw-   LastModificationTime                          0
-rw-   LogFormatCompatibilityEnabled                 false
-rw-   MaxConcurrentLongRunningRequests              50
-rw-   MaxConcurrentNewThreads                       50
-rw-   MsgIdPrefixCompatibilityEnabled               true
-rw-   Name                                          base_domain
-rw-   Notes                                         null
-rw-   OCMEnabled                                    true
-rw-   ParallelDeployApplicationModules              false
-rw-   ParallelDeployApplications                    false
-rw-   ProductionModeEnabled                         false
-rw-   RootDirectory                                 null
-rw-   ServerMigrationHistorySize                    -1
-rw-   ServiceMigrationHistorySize                   -1
-rw-   SiteName                                      null
-rw-   Tag
wls:/offline/>    



Set.

Vamos a modificar sólo un par de cosas para nuestro nuevo dominio, primeramente, modificaremos un par de valores del AdminServer, su ListenAddress y su ListenPort, para esto debemos primero colocarnos en la posición correcta dentro de la jerarquía de nuestro template:

wls:/offline/>cd('Servers/AdminServer')
wls:/offline//Server/AdminServer>


Observa nuevamente como el prompt cambia, si escribes un ls() podrás ver el listado que ya conocemos. Vamos a modificar los valores que indicamos, para ello vamos a utilizar el comando set.

Vamos a ver que dice la ayuda.

wls:/offline//Server/AdminServer>help('set')

Description:


Sets the specified attribute value for the current configuration bean.
For more information about the MBean attributes that can be set, see
"WebLogic Server MBean Reference" at
http://www.oracle.com/technology/products/weblogic/index.html.

In the event of an error, the command returns a WLSTException.

You can list all attributes and their current values by entering
ls('a'). For more information, see help('ls').

When you use this command for a domain configuration MBean, the
new values are saved in the config.xml file. Please note the following
when using WLST Online:
- You cannot use the set command when WLST is connected to a Managed
 Server instance.

- While you cannot use WLST to change the values of MBeans on Managed
 Servers, it is possible to use the Management APIs to do so.
 Oracle recommends that you change only the values of
 configuration MBeans on the Administration Server. Changing the
 values of MBeans on Managed Servers can lead to an inconsistent
 domain configuration.

Alternatively, you can use the cmo variable to perform any set
method on the current configuration bean. For more information about
the cmo variable, see "Changing the Current Management Object" in
"WebLogic Scripting Tool" at
http://www.oracle.com/technology/products/weblogic/index.html.

Syntax:

set(attrName, value)
- attrName = Name of the attribute to be set.

- value = Value of the attribute to be set. This value should
 not be enclosed in single or double quotes.

Example:


wls:/mydomain/serverConfig> set('ArchiveConfigurationCount',10)    


Con el comando set podemos modificar los valores del MBean actual, esto es, el MBean de la posición actual en la que estamos. Dado que estamos en el AdminServer, las modificaciones que hagamos serán sobre este.

La sintaxis es:

set(attrName, value)
- attrName = Name of the attribute to be set.


Entonces, dados los campos que queremos cambiar, esto se convierte en:

set('ListenAddress','127.0.0.1')
set('ListenPort', 7003)


Pusimos 127.0.0.1 ya que queremos probar la creación del dominio de manera local y, hemos asignado el puerto 7003, asumiendo que queremos convivir con el dominio existente, el cual escucha en el puerto 7001.

Vamos a ejecutar estas líneas:

wls:/offline//Server/AdminServer>set('ListenAddress','127.0.0.1')
wls:/offline//Server/AdminServer>set('ListenPort', 7002)


Ya no vamos a modificar nada más del AdminServer así que, volveremos a subir en la jerarquía para configurar nuestro usuario de administración.

wls:/offline//Server/AdminServer>cd('/')
wls:/offline/>


Configuraremos al usuario weblogic:

wls:/offline/>cd('Security/base_domain/User/weblogic')
wls:/offline//Security/base_domain/User/weblogic>


De nuestro Usuario únicamente vamos a asignarle un password:

wls:/offline//Security/base_domain/User/weblogic>cmo.setPassword('weblogic33')
wls:/offline//Security/base_domain/User/weblogic>


Volvemos a subir en la jerarquía de nuestro dominio nuevamente:

wls:/offline//Security/base_domain/User/weblogic>cd('/')
wls:/offline/>


Y ya sólo nos faltan dos líneas para terminar de crear nuestro dominio:



setOption.

Primero indicaremos que queremos sobre escribir el dominio la información de los templates con lo que hemos modificado, para ellos usaremos el comando: setOption.

Veamos que dice la ayuda:

wls:/offline>help('setOption')

Description:


Sets options related to a domain creation or update. In the event of an error, the command 
returns a WLSTException.

Syntax:

setOption(optionName, optionValue)
- optionName = Name of the option to set.
 Available options for domain creation include:
 o DomainName = Name of the domain. By default, the name of  the domain is derived from the 
name of the domain directory.
 For example, for a domain saved to
 c:/Oracle/Middleware/user_projects/domains/myMedrec, the domain name is  myMedrec. By setting 
DomainName, the name of the created  domain will be independent of the domain directory name.

 o JavaHome = Home directory for the JVM to be used when starting the server. This option 
defaults to the Sun JDK installed with the product.

 o OverwriteDomain = Boolean value specifying whether to allow an existing domain to be 
overwritten. This option  defaults to false.

 o ServerStartMode = Mode to use when starting the server for the newly created domain. This 
value can be dev (development) or prod (production). This option defaults to dev.

 Available options for domain upgrades include:
 o AllowCasualUpdate = Boolean value specifying whether  to allow a domain to be updated without 
adding an extension  template. The default is true. This option defaults to true.

 o ReplaceDuplicates = Boolean value specifying whether  to keep original configuration elements 
in the domain or replace  the elements with corresponding ones from an extension template  when 
there is a conflict. This option defaults to true.

 Available options for both domain creation and domain upgrades
 include:
 o AppDir = Application directory to be used when a separate  directory is desired for 
applications, as specified by the  template. This option defaults to
 BEAHOME/user_projects/applications/domainname, where BEAHOME  specifies the home directory 
and domainname specifies the  name of the domain.

 o AutoAdjustSubDeploymentTarget = Boolean value  specifying whether WLST automatically adjusts 
targets for the subdeployments of AppDeployments. This option defaults  to true. To deactivate 
this feature, set the option to  false and explicitly set the targeting for AppDeployment  
subdeployments before writing or updating the domain or  domain template.

 o AutoDeploy = Boolean value specifying whether  to activate auto deployment when a cluster or 
multiple  Managed Servers are created. This option defaults to true.
 To deactivate this feature, set the option to false on the  first line of your script.

 o NodeManagerType = Node Manager Type to be used to create  a node manager for the domain. This 
option defaults to  "PerDomainNodeManager". This value can be PerDomainNodeManager,  
CustomLocationNodeManager or ManualNodeManagerSetup.

 o NodeManagerHome = Node Manager home is a node manager directory to be  created for the domain. 
This option is used when node manager type is  CustomLocationNodeManager.

 o OldNodeManagerHome = A Node Manager home directory from which the existing  configuration is 
taken for Node Manager upgrade during domain reconfiguration.
 This option applies only when the Node Manager upgrade type is "Migrate".

 o NodeManagerUpgradeType = Node Manager upgrade can be "New" or "Migrate".
 "New" does not use an old Node Manager configuration and creates the  specified type of Node 
Manager. "Migrate" migrates the Node Manager configuration  from the Node Manager home specified 
by the "OldNodeManagerHome" option.
 This option is used for upgrading Node Manager during domain reconfiguration when the Node 
Manager type is either PerDomainNodeManager or CustomLocationNodeManager.

 o NodeManagerUpgradeOverwriteDefault = A boolean flag that is used to overwrite the  
Oracle-recommended default values for mandatory Node Manager configuration. This  option 
is used only when Node Manager upgrade type is "Migrate". The default value is false.

- optionValue = Value for the option. Note that boolean values can be specified as a String 
(true, false) or integer (0, 1).

Example:

wls:/offline> setOption('CreateStartMenu', 'false')


Lo que queremos con setOption es indicar que queremos sobre escribir el dominio con los cambios que hemos indicado, eso lo haremos con la siguiente línea.

setOption('OverwriteDomain', 'true')


Ejecutamos la línea:

wls:/offline/>setOption('OverwriteDomain', 'true')


Si no ejecutamos la línea anterior, los cambios que hicimos no se reflejarán al momento de grabar el dominio.

Y por último vamos a escribir (grabar) nuestro dominio, esto es, tanto los templates como las modificaciones que realizamos serán escritas a disco.

Esto se realiza con el comando: writeDomain.



writeDomain.

Veamos que dice la ayuda de este comando:

wls:/offline/>help('writeDomain')

Description:


Writes the domain configuration information to the specified directory.

Once your write the domain to the file system, you can continue to update
the domain template object that exists in memory, and reissue the
writeDomain command to store the domain configuration to a new or existing
file.

By default, when you write a domain, the associated applications are written
to BEAHOME/user_projects/applications/domainname, where BEAHOME specifies
the home directory and domainname specifies the name of the domain.
This directory must be empty; otherwise, WLST displays an error.

When you have finished using the domain template object in memory, close
it using the closeTemplate command. For more information, see help('closeTemplate').
If you want to edit the domain that has been saved to disk, you can open it
using the readDomain command. For more information, see help('readDomain').

NOTE: The name of the domain is derived from the name of the domain
directory. For example, for a domain saved to
c:/Oracle/Middleware/user_projects/domains/myMedrec, the domain name is myMedrec.

Before writing the domain, you must define a password for the default user,
if it is not already defined. For example:
cd('/Security/base_domain/User/adminusername')
cmo.setPassword('adminpassword')

In the event of an error, the command returns a WLSTException.

Syntax:

writeDomain(domainDir)
- domainDir = Name of the directory to which you want to write the domain
 configuration information.

Example:

wls:/offline/wls_medrec> writeDomain('c:/Oracle/Middleware/user_projects/domains/medrec')    


Así que, vamos a escribir el dominio, vamos a elegir la carpeta por default para colocar el dominio. Le llamaremos: wlst_domain a nuestro dominio.

wls:/offline/>writeDomain(' /Users/
user1/Oracle/Middleware/Oracle_Home/user_projects/domains/wlst_domain')

Y siguiendo la recomendación de la ayuda, cerraremos el template con closeTemplate.

wls:/offline/wlst_domain/wlst_domain>closeTemplate()
wls:/offline>


Listo, el dominio ha sido creado.


Cerremos la sesión de wlst.

wls:/offline/wlst_domain/wlst_domain>exit()
Exiting WebLogic Scripting Tool.


Las líneas que ejecutamos fueron las siguientes:

/Users/user1/Oracle/Middleware/Oracle_Home/oracle_common/common/bin> ./wlst.sh

Initializing WebLogic Scripting Tool (WLST) ...

Welcome to WebLogic Server Administration Scripting Shell

Type help() for help on available commands

wls:/offline> selectTemplate("Basic WebLogic Server Domain", "12.2.1")
wls:/offline/>selectTemplate("Oracle Enterprise Manager-Restricted JRF", "12.2.1")
wls:/offline/>loadTemplates()
wls:/offline/>cd('Servers/AdminServer')
wls:/offline//Server/AdminServer>set('ListenAddress','127.0.0.1')
wls:/offline//Server/AdminServer>set('ListenPort', 7003)
wls:/offline//Server/AdminServer>cd('/')
wls:/offline/>cd('Security/base_domain/User/weblogic')
wls:/offline//Security/base_domain/User/weblogic>cmo.setPassword('weblogic33')
wls:/offline//Security/base_domain/User/weblogic>cd('/')
wls:/offline/>setOption('OverwriteDomain', 'true')
wls:/offline/>writeDomain('/domains/wlst_domain')
wls:/offline/wlst_domain/wlst_domain>closeTemplate()
wls:/offline>exit()


Y nuestro script quedaría:

# createdomain.py
selectTemplate("Basic WebLogic Server Domain", "12.2.1")
selectTemplate("Oracle Enterprise Manager-Restricted JRF", "12.2.1")
loadTemplates()
cd('Servers/AdminServer')
set('ListenAddress','127.0.0.1')
set('ListenPort', 7003)
cd('/')
cd('Security/base_domain/User/weblogic')
cmo.setPassword('weblogic33')
cd('/')
setOption('OverwriteDomain', 'true')
writeDomain('/domains/wlst_domain')
closeTemplate()
exit()


Vamos a validarlo.




startWeblogic.


Los datos de nuestro dominio creado son los que especificamos en el script:

Host

127.0.0.1

Puerto

7003

Usuario

Weblogic

Password

weblogic33

Nombre del dominio

wlst_domain

Ubicación del dominio

ORACLE_HOME/user_projects/domains/domains/wlst_domain



Vamos a la carpeta donde creamos el dominio, entramos a la carpeta /bin y ejecutaremos: startWeblogic.

wlst_domain/bin>./startWeblogic.sh


Esperamos a que el log indique que el dominio está en RUNNING.

<21/03/2018 01:22:17 PM CST> <Notice> <WebLogicServer> <BEA-000365> 
<Server state changed to ADMIN.>
<21/03/2018 01:22:17 PM CST> <Notice> <WebLogicServer> <BEA-000365> 
<Server state changed to RESUMING.>
<21/03/2018 01:22:17 PM CST> <Notice> <WebLogicServer> <BEA-000331> 
<Started the WebLogic Server Administration Ser
AdminServer" for domain "wlst_jrf_5" running in development mode.>
<21/03/2018 01:22:17 PM CST> <Notice> <Server> <BEA-002613> <Channel "Default" 
is now listening on 127.0.0.1:7003 fotocols iiop, t3, ldap, snmp, http.>
<21/03/2018 01:22:17 PM CST> <Notice> <Server> <BEA-002613> <Channel "Default"
is now listening on 127.0.0.1:7003 fotocols iiop, t3, ldap, snmp, http.>
<21/03/2018 01:22:17 PM CST> <Notice> <WebLogicServer> <BEA-000360> <The server 
started in RUNNING mode.>
<21/03/2018 01:22:17 PM CST> <Notice> <WebLogicServer> <BEA-000365> <Server 
state changed to RUNNING.>


 Nuestro dominio está en funcionamiento.




Validación.


Como recordamos elegimos el puerto 7003 para no chocar con un posible dominio existente por ello es que accedemos de la siguiente manera:

http://127.0.0.1:7003/console


Validamos la url de administración que asignamos.


Figura 4. Pantalla de login de nuestro dominio creado.


Accedemos con los valores que indicamos.


Figura 5. Dominio wlst_domain.


El segundo template que seleccionamos nos permite entre otras funcionalidades tener disponible Enterprise manager, por lo tanto, debemos tener acceso a:

http://127.0.0.1:7003/em/


Figura 6. Enterprise Manager. Pantalla de login.


Utilizamos las mismas credenciales


Figura 7. Enterprise Manager. Pantalla principal.


Hemos creado un dominio WLS 12c  utilizando WLST.

Enhorabuena!

Ahora, puedes aplicar tus conocimientos y hacer una versión del script que lea los parámetros desde un archivo de propiedades.




Conclusión.


Hemos conocido un poco más sobre WLST, tenemos ya el concepto de cmo y con ello hemos podido crear un script para crear un dominio.

En esta parte de la serie, navegamos más por la jerarquía de nuestro dominio, y hemos comenzado a conocer otros comandos de WLST.

En próximas entregas de esta serie seguiremos conociendo más sobre la creación de scripts para diversas tareas del día a día.




Enlaces.




Isaac Ruiz Guerra (@rugi), es programador Java yConsultor TI. Especializado en integración de sistemas, fundamentalmente relacionados con el sector financiero. Actualmente forma parte del equipo de S&P Solutions. Escribe en su blog personal xhubacubi.blogspot.com, pero también participa y pertenece a www.javahispano.org y a www.javamexico.org

Este artículo ha sido revisado por el equipo de productos Oracle y se encuentra en cumplimiento de las normas y prácticas para el uso de los productos Oracle.