Dynamic Cluster Scaling with WLST

Dynamic Cluster configuration on WebLogic Domain

Prerequisites

• Install Oracle WebLogic 12.2.1 or above versions on any platform
• Configure a fresh WebLogic domain 

In this exciting example 😊 new learning about how to use the dynamic cluster in the latest version of WebLogic 12c [12.1.2] and above this was introduced for WebLogic on Cloud computing. To workout this you must configure a Server template when you give the maximum number of cluster servers these managed server automatically increased. When you decrease it the number of managed servers come to SHUTDOWN state as expected. To do same task from the automation using WLST prompt you need to use the following two functions:

1. scaleUp increase the number of managed servers in the cluster
2. scaleDown to decrease the number of managed servers in the cluster.

Dynamic Cluster configuration on WebLogic Domain

now let's do the automation exercise

# Dated  : 4th Feb 2016
# ScriptName : dynamicCluster.py
# Purpose :
# This script will create server template and using that
# configures a dyanamic cluster

def createServer_Template(tmpName, basePort, sslPort, machine):
        print 'creating server tempalte for '+tmpName
        cd('/')
        cmo.createServerTemplate(''+tmpName)

        cd('/ServerTemplates/'+tmpName)
        cmo.setListenPort(int(basePort))

        cd('/ServerTemplates/'+tmpName+'/SSL/'+tmpName)
        cmo.setListenPort(int(sslPort))

        cd('/ServerTemplates/'+tmpName)
        cmo.setMachine(None)


def create_dynamicCluster(clustrName, tmpName, prefix):
        print 'Creating dynamic cluster: '+clustrName
        cd('/')
        cmo.createCluster(clustrName)

        cd('/Clusters/'+clustrName)
        cmo.setClusterMessagingMode('unicast')

        cd('/ServerTemplates/'+tmpName)
        cmo.setCluster(getMBean('/Clusters/'+clustrName))

        cd('/Clusters/'+clustrName+'/DynamicServers/'+clustrName)
        cmo.setServerTemplate(getMBean('/ServerTemplates/'+tmpName))
        cmo.setDynamicClusterSize(2)
        cmo.setMaxDynamicClusterSize(8)
        cmo.setCalculatedListenPorts(true)
        cmo.setCalculatedMachineNames(true)
        cmo.setCalculatedListenPorts(true)
        cmo.setServerNamePrefix(prefix)

def main():
        connect("weblogic","welcome1","t3://192.168.33.100:6100")
        edit()
        startEdit()

        print 'Creating server templates...'
        # creating server templates
        createServer_Template('app_tier_tmp', 7120, 8120, 'mydev')
        createServer_Template('web_tier_tmp', 6120, 9120, 'mydev') # Machine already configured

        create_dynamicCluster('app_dclustr', 'app_tier_tmp','app_server0')
        create_dynamicCluster('web_dclustr', 'web_tier_tmp','web_server0')
        print 'Dynamic cluster configuration completed...'
        activate()

main()

The above generic WLST script can be executed as shown below:

You could also double confirm this from your WebLogic Admin Console work-area when you select clustser in the Environment of under your Domain .

Dynamic Cluster configuration in WebLogic 12.2.1 Domain

Suggestion for future enhancements to the above script you can do following:

1. create a properties file and pass all the main program required arguments
2. Cluster Message Mode can be dynamic
3. Machine per template can be set dynamic

Elastic Cluster on-demand scale up

In the WLST prompt you can test it as :

scaleUp ("app_dclustr",1, true, true)

scaleUp execution for single server:

ScaleUp in WLST Execution 

scaleDown('app_dclustr',2,true,true)

Scale down weblogic cluster

Scale Down cluster size in WLST

Hope you enjoyed this post,  Stay tune to this blog post and share with your friends techies...

Waiting for your comments and suggestions!!

Home

Do you know this fun thing about Python scripting sing a poem of quotations just by by importing 'this' module.

wls:/offline> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
wls:/offline>

wlst

More PowerPoint presentations from Shailaja Gadagoju

Content

1. Overview of WLST
2. Input and Output in WLST
3. WLST Online vs Offline
4. Best WLST Editor: OEPE
5. WLST Errors and Exceptions
6. Switching from edit tree
7. WLST starting issues
8. NodeManager with WLST
9. Command line options for WLST
10. Configuring a WL Domain
11. Configuring Multidatasource by WLST
12. Configuring a Generic datasource
13. Configuring GridLink Datasource
14. Configuring WorkManagers with WLST
15. WebLogic domain migration with WLST
16. Monitoring JVM using WLST
17. WLST Tips & Tricks
18. Monitoring Thread Pool
19. Monitoring JMS using WLST
20. Monitoring Multidatasource/connection pool
21. Monitoring Connection pool with admhome
22. ServerState Mail with WLST
23. Side by Side Deployment with WLST
24. 24X7 Restart strategy with WLST
25. Server state by WLST
26. Server start-time using WLST
27. Store output using WLST Files
28. Cosmotizing your WLST output
29. WebLogic 8.1 model thread count
30. 
    

You are invited for the contribution of WLST scripts and articles.

Technorati Claim token code JDU3DCFE66EH

WebLogic Scripting Tool (WLST) Overview

-->

There are many newbies into the WebLogic stream ( Development/ Administration). Most of them are novice to WLST. I thought let me found a way to give you best links available on the net.

After being in the development team one of my buddy asked me "your blogs are very nice, I want to learn WLST. But where to start? " My answer for all my blog readers who want to encourage newbies in WLST can pass this post. Currently WLST is supporting Application Servers are listed as follows:

• WebLogic 8.1
• BEA WebLogic 9.0
• BEA WebLogic 9.1
• BEA WebLogic 9.2
• BEA WebLogic 10.0

WLST is first initiated in the BEA System Inc., days so it is supported since WebLogic 8.1 onwards with latest service packs till WebLogic version 10.0. After Oracle acquisition following are the versions:

• Oracle WebLogic 10g R3
• Oracle WebLogic 11gR1
• Oracle WebLogic 11gR1 PatchSet 1 (10.3.1)
• Oracle WebLogic 11gR1 PatchSet 2 (10.3.2)
• Oracle WebLogic 11gR1 PatchSet 3 (10.3.3)
• Oracle WebLogic 12c

WLST Features indentation - Clear Sytax

The WLST programming structure follows strict syntax indentation and it is the same structure as in Python programming. As per my experiances with WLST it can be divided into four parts

1. Importing section
2. Global variables
3. Definations - class/function
4. Main program uses above sections

Import section for Reuse
importing WLST libraries includes Python standard libraries and thousands of new Jython libraries also included. You can have Java packages as module imports which gives you flexible programming.

While writing a WLST script, the file can be store with the extension .py are called python modules. We can reuse the external language such as Java methods into our WLST script you can use import statement for this. Here is the syntaxes that you can use.

import module
from module import submodule
from . import submodule

You can write a WLST script that uses command line aruguments using sys module sys.args.

WLST Datatypes - Global variables

In WLST you can define the global variables on the top of the program that can be used across all the functions defined in the script. On the other hand you can define the variables in the function definitions that can be treated as local to the function, Jython programming language supported datatypes all can be used it supports

• Base Datatypes: integer, float, long, char, str, bool
• Collection Types: list, dictionary, tuple, sequances, maps etc
• Object types: Python objects and Java package objects

Dynamic typing

In WLST supports Python Dynamic typing, we can use same variable for storing different type of data as shown below.

wls:/offline> # VAR CAN CHANGE INTO MANY TYPES
wls:/offline> var=10
wls:/offline> print var
10
wls:/offline> var='Busy in WLST'
wls:/offline> print var
Busy in WLST
wls:/offline> var=[1,2,3]
wls:/offline> print var
[1, 2, 3]

Class in WLST

Object oriented scripting can be defined and can be reusable with creation of objects.

 
class CLASSNAME:
 def __init__():   #like C++ constructor
  self.name
  do something initially
 def function1():
  do some task 

Let’s experiment with class in WLST. In a class we can define attributes and we can assign values to them. And we define functions related to that class that you will make.

wls:/offline> class test:
...     u,p='weblogic','vybhav@28'
...

After this we are able to create instances of the class test. Let us create t as a instance of test class.

wls:/offline> t=test()
wls:/offline> print t.u,t.p
weblogic vybhav@28

There is a difference between class attribute and instance attributes. Let us know about it, The variables u, and p of the instance can be modified by assignment:

wls:/offline> t.u='vasuakka'
wls:/offline> t.u
'vasuakka'

In u attribute value was changed into ‘vasuakka’ instead of ‘weblogic’.

Function definitions in WLST

How to define a Function in WLST? It is simple it starts with keyword ‘def’, you need to give a name of the function followed by number of argument and a colon. After this you need to give a tab space indentation that indicates the function block. You can add text to tell about what this function will do. Then you can add number of WLST statements or control flow statements. At the bottom of the function you can return a value or you leave that line, it is optional.

Now, let’s experiment with function definition for conversion of Kilobytes to megabytes. The logic of this function is that we can get the megabyte value when you pass the argument as kilobyte this will be divided by 1024.

wls:/offline> def kb2MB(kb):
...     mb=kb/1024
...     return mb
...
wls:/offline> print kb2MB(2048)
2

WLST Operators

You WLST commands statements not only JMX accessing functions we need to use some of the Python programming control flows in it. To use the control flow you must know about what kind of operations you can do in WLST. So let us see some of them are:

Comparison operators
This opertators we can use in regular if statements or while statements

==, >, <, <=, =>

Logical Operators
In WLST the variable can be empty or zero values are treated as "", 0, None, 0.0, [], and {}. So you need to be careful when you define a variable and moved the values of variables.

How WLST script Execution works?

Here I am going to explain with the following picture, how the Python script will be interpreted and internally compiled to java code and then Byte code so that it can be executable on JVM.

WLST Execution process

The source code for the WLST script is written in Python code. The WLST program file must have the extension as .py which is the source code consisting a set of Jython instructions for WebLogic domain. This source code is going to use a JVM machine when it is instructed to RUN the script; its invocation internally generates Java byte code to interpret with the JVM to produce the desired output. You might wonder by seeing this Chines WLST link, but it is worthy to see in google chrome. Because the web-page is from china and entire page is in chaineese language. If you have Google Chrome it will give you translate on top of the page you can choose your choice of language and have knowledge on WLST :) Here I am sharing the wonderful presentation about WLST overview. Check this following SlideShare Presentation: it's pretty informative, it was delivered by James Bayer who is the technical expert from Oracle. Especially I more impressed myself to see the 47 slide saying about THIS blog as one of the web reference.

WebLogic Scripting Tool Overview from James Bayer

Thankyou for visiting this post, feel free to post your comments after viewing these video links.