Monday Feb 15, 2016

WebLogic on Docker Containers Series, Part 3: Creating a Domain Image

You already know how to quickly get started with WebLogic on Docker. You also learned with more details how to build an installation Docker image of WebLogic and Oracle JDK. This time, you will learn how to create a WebLogic Domain Image for Docker Containers.

We are pushing some interesting samples of Docker images on GitHub so this way WebLogic customers and users can have a good idea of what is possible (although not everything in there may be officially supported as of this moment, like multihost), but to experiment and learn more about Docker itself. This blog post focuses on the 1221-domain sample, but make sure to subscribe to this blog or follow me on Twitter for future posts that will look into the other samples.

I will also assume that you have the docker-images repository checked out and updated in your computer (with commit 4c36ef9f99c98), and of course you have Docker installed and properly working. Now moving on. 

WebLogic Domains

WebLogic uses a Domain concept for its infrastructure. This is the first thing a developer or administrator must create in order to be able to run a WebLogic Server. There are many ways to create a WebLogic Server Domain: using the Configuration Wizard, using WLST, or even bootstrapping the weblogic.Server class. Since we are using Docker and we want to automate everything, we create the domain with WLST.

TL;DR; Building the Domain Image in 1221-domain sample

First things first, make sure you have image oracle/weblogic:12.2.1-developer already created. If not, check Part 2 of this series to learn how. 

Now go into folder samples/1221-domain and run the following command:

$ pwd
$ docker build -t 1221-domain --build-arg ADMIN_PASSWORD=welcome1 .
$ docker images
REPOSITORY              TAG                     IMAGE ID            CREATED             SIZE
1221-domain             latest                  327a95a2fbc8        2 days ago          1.195 GB
oracle/weblogic         12.2.1-developer        b793273b4c9b        2 days ago          1.194 GB
oraclelinux             latest                  4d457431af34        10 weeks ago        205.9 MB

This is what you will end up having in your environment. 

Understanding the sample WLST domain creation script

Customers and users are always welcome to come up with their own scripts and automation process to create WebLogic domains (either for Docker or not), but we shared some examples here to make things easier for them.

The 1221-domain sample has a subfolder named container-scripts that holds a set of handy scripts to create and run a domain image. The most important script though is the WLST script. This file is executed when docker build is called, as you can see in the Dockerfile. In this sample, you learn how to read variables in script with default values, that may be defined in the Dockerfile.

The script defined in this sample requires a set of information in order to create a domain. Mainly, you need to provide:

  • Domain name: by default 'base_domain'
  • Admin port (although WLS has 7001 by default when installed, this script defaults to 8001 if nothing is provided)
  • Admin password: no default. Must inform during build with --build-arg ADMIN_PASSWORD=<your password>
  •  Cluster Name: defaults to 'DockerCluster' 

Note about About Clustering

This sample shows how to define a cluster named with whatever is in $CLUSTER_NAME (defaults to DockerCluster) to demonstrate scalability of WebLogic on Docker containers. You can see how the Cluster is created in the WLST file.

Back to the domain creation

How to read variables in WLST with default values? Pretty simple:

domain_name = os.environ.get("DOMAIN_NAME", "base_domain")
admin_port = int(os.environ.get("ADMIN_PORT", "8001"))
admin_pass = os.environ.get("ADMIN_PASSWORD")
cluster_name = os.environ.get("CLUSTER_NAME", "DockerCluster")

These variables can be defined as part of your Dockerfile, or even passed as arguments during build if you are using Docker 1.10 with the new ARG command, as the ADMIN_PASSWORD example shows.

ENV DOMAIN_NAME="base_domain" \
ADMIN_PORT="8001" \
ADMIN_HOST="wlsadmin" \
NM_PORT="5556" \
MS_PORT="7001" \
CLUSTER_NAME="DockerCluster" \

Other variables are defined here (NM_PORT, MS_PORT, ADMIN_HOST), but I'll explain them later on a future post. Meanwhile, let's continue.

The next step as part of a domain image creation, is that you may want to reuse some Domain Template. In the sample script, we used the default template for new domains wlst.jar, but agan if you are working on your own set of domains feel free to use any template you may already have.

Next we tell WLST to configure the AdminServer to listen on all addresses that will be available (in the container), and to listen on port as in $ADMIN_PORT.

The 'weblogic' admin user needs a password that you had to provide with --build-arg (or defined directly inside Dockerfile) in $ADMIN_PASSWORD, and then we set that in the script.

For the sake of providing some examples, we also define a JMS Server in the script, but we only target it to the AdminServer. If you want to target to the Cluster, you will have to tweak your own script. 

The script is configured to set this domain in Production Mode too. 

We set some Node Manager options, since we will be using NM as Per Domain (see docs for more details). Remember that each instance of this image (a container) has the same "filesystem", so it is as if you had copied the domain to different servers. If you are an experienced WebLogic administrator, you will quickly understand. If not, please comment and I'll share some links. This is important to be able to run Managed Servers inside containers based on this image. I'll get back to this in the future on running a Clustered WebLogic environment on Docker containers.

There are a couple of other things we could've done in this script, such as:

  • Create and define a Data Source
  • Create, define, and deploy applications (this is demonstrated as part of the 1221-appdeploy sample)
  • And anything else you can do with WLST in Offline mode (remember that domain does not exist and thus is not running)

But sure you will quickly find out how to do these for your own domains.

Now that you have a domain Docker image 1221-domain, you are able to start it with:


$ docker run -ti 1221-domain


Now have some fun with tweaking your own WLST scripts for domain creation in Docker.

Wednesday Jan 06, 2016

WebLogic on Docker Containers Series, Part 2

On my previous post, the first part of this series, I've shown to you how to quickly get started with WebLogic on Docker. You've learned how to create a base Docker image with WebLogic and Oracle JDK installed, and then how to create a second image that contains a configured WebLogic domain. Today's post will break down and explain what happens behind the scenes of that process

Note: for the sake of history and keep this blog post useful in the future, I will refer to the commit 7741161 from the docker-images GitHub project, and version 12.2.1 of WebLogic.

Walking through the build process of a WebLogic base image

A base image of WebLogic means an image that contains only the software installed with minimum configuration, to further be extended and customized. It may be based on a Red Hat base Docker image, but preferably, we recommend you to use the Oracle Linux base image.

Samples for how to build a base image are presented in the dockerfiles folder. Files for WebLogic versions 12.1.3 and 12.2.1 are maintained there, as well for two kinds of distributions: Developer, and Generic. Other versions and distributions may be added in the future.

Differences between Developer and Generic distributions

There aren't many differences between them, except these (extracted from the README.txt file inside the Quick Installer for Developer):


- Native JNI libraries for unsupported platforms.
- Samples, non-english console help (can be added by using the WLS supplemental Quick Install)
- Oracle Configuration Manager (OCM) is not included in the Quick installer
- SCA is not included in the Quick Installer

Also, the Quick Installer for Developers is compressed using pack200, an optimized compression tool for Java classes and JAR files, to reduce the download size of the installer. Besides these differences, the two distributions work perfectly fine for Java EE development and deployment.

Building the Developer distribution base image

Although we provide a handy shell script to help you in this process, what really matters relies inside 12.2.1 folder and the Dockerfile.developer file. That recipe does a COPY of two packages, the RPM of JDK, and the WebLogic Quick Installer. These files must be present. We've put these .download files as placeholders to remind you of the need to download them. This same approach will apply for the Generic distribution.

The installation of JDK uses rpm tool, which enables us to run Java inside the base image. A very obvious requirement. After JDK is installed, we proceed with the installation of WebLogic by simply calling "java -jar", and later we clean up yum.

An important observation is the use of /dev/urandom in the Dockerfile. WebLogic requires some level of entropy for random bits that are generated during install, and as well domain creation. It is up to customers to decide whether they want to use /dev/random or /dev/urandom. Please configure this as desired.

You can build this image in two ways:

  1. Using script. Indicate you want developer distribution [-d], and version 12.2.1 [-v 12.2.1].

    $ pwd
    $ sh -d -v 12.2.1

  2. Manually calling docker build:

    $ cd 12.2.1
    $ docker build -t oracle/weblogic:12.2.1-dev -f Dockerfile.developer .

Either of these calls result in the following:

REPOSITORY          TAG            IMAGE ID         CREATED          VIRTUAL SIZE
oracle/weblogic     12.2.1-dev     99a470dd2110     15 secs ago      1.748 GB
oraclelinux         7              bea04efc3319     5 weeks ago      206 MB
oraclelinux         latest         bea04efc3319     5 weeks ago      206 MB

As you may have know by now, this image contains only WebLogic and JDK installed, and thus does not serve to be executed, only to be extended.

Building the Generic distribution base image

Most of what you've learned from above applies to the Generic distribution. The differences are that you must download, obviously, the Generic installer. The installation process is a little bit different, since it uses the silent install mode, with environment definition coming from install.file and oraInst.loc.

To build this image you either do by:

  1. Call script. Indicate you want Generic distribution [-g], and version 12.2.1 [-v 12.2.1].

    $ pwd
    $ sh -g -v 12.2.1

  2. Manually calling docker build:

    $ cd 12.2.1
    $ docker build -t oracle/weblogic:12.2.1 -f Dockerfile.generic .

Now you have two images you can extend from, either the Developer, or the Generic base image:

REPOSITORY          TAG            IMAGE ID         CREATED          VIRTUAL SIZE
oracle/weblogic     12.2.1         ea03630ee95d     18 secs ago      3.289 GB
oracle/weblogic     12.2.1-dev     99a470dd2110     2 mins ago       1.748 GB
oraclelinux         7              bea04efc3319     5 weeks ago      206 MB
oraclelinux         latest         bea04efc3319     5 weeks ago      206 MB

Note how the Generic image is larger than the developer image. That's because the Developer distribution contains less stuff inside, as described earlier. It will be up to Dev and Ops teams to decide which one to use. And how to build them.

In the next post, I will walk you through the process of building the 1221-domain sample image.

If you have any questions, feel free to comment, or tweet.

Monday Jan 04, 2016

WebLogic on Docker Containers Series, Part 1

WebLogic 12.2.1 is certified to run Java EE 7 applications, supports Java SE 8 (since 12.1.3), and can be deployed on top of Docker containers. It also supports Multitenancy through the use of Partitions in the domain, enabling you to add another level of density to your environment. Undeniably, WebLogic is so much of a great option for Java EE based deployments that both developers and operations will benefit from. Even Adam Bien, Java EE Rockstar, has agreed with that.

But you are here to play with WebLogic and Docker, so first, check these links about the certification and support:

Understanding WebLogic on Docker

We recommend our customers and users to build their own image containing WebLogic and Oracle JDK installed without any domain configured. Perhaps a second image containing a basic domain. This is to guarantee easier reuse between DevOps teams. Let me describe an example: Ops would provide a base WebLogic image to Dev team, either with or without a pre-configured domain with a set of predefined shell scripts, and Devs would perform domain configuration and application deployment. Then Ops get a new image back and just run containers out of that image. It is a good approach, but certainly customers are free to think out of the box here and figure out what works best for them.


Alright, alright... Do the following:

1 - Download docker-images' file repository directly and drop somewhere.

$ unzip && mv docker-images-master docker-images

2 - Download WebLogic 12.2.1 for Developers and Oracle JDK 8 specific versions as indicated in Checksum.developer. Put them inside dockerfiles/12.2.1 folder. You will see placeholders there (*.download files).

3 - Build the installation image

$ cd docker-images/OracleWebLogic/dockerfiles

$ sh -d -v 12.2.1

4. Build the WebLogic Domain image

$ cd ../samples/1221-domain

$ docker build -t 1221-domain .

5. Run WebLogic from a Docker container

$ docker run -d -p 8001:8001 1221-domain

6. Access Admin Console from your browser: http://localhost:8001/console

Note that these steps are for your first image build only. Customers are encouraged to run a Docker Registry at their internal network, and store these images there just as they probably already do with Oracle software installers at some intranet FTP server. Important! Do not share binaries (either packed as a Docker image or not).

* follow this series if you want to learn more of WebLogic on Docker. But please do read the entire post... :-)

Creating your first WebLogic Docker Image

The very first step to get started, is to checkout the docker-images project on GitHub:

$ git checkout --depth=1

If you don't have or don't want to install the Git client, you can download the ZIP file containing the repository and extract it. Use your browser, or some CLI tool.

Another thing to know before building your image, is that WebLogic comes in two flavors: one is the Developer distribution, smaller, and the other is the Generic distribution, for use in any environment. For the developer distribution, you have to download two files indicated inside Checksum.developer. If you want to build the Generic distribution instead of the Developer, see file Checksum.generic for further instructions, but tl;dr; you need two files again (or one if you have downloaded JDK already). The same instructions apply.

Next step is to go to the terminal again and use the handy shell script, which will do some checks (like checksum) and select the proper Dockerfile (either .developer or .generic) for the specific version you want, although I do recommend you start with 12.2.1 from now on.

$ cd docker-images/OracleWebLogic/dockerfiles
$ sh -d -v 12.2.1

You may notice that it takes some time to copy files during the installation process. That's because WebLogic for Developers is compressed with pack200 to be a small download. But after you build this image, you can easily create any domain image on top of it, and you can also share your customized image using docker save/load. Next step is to create a WebLogic Domain.

Creating the WebLogic Domain Image

So far you have an image that is based on Oracle Linux 7 and has WebLogic 12.2.1 for Developers, and Oracle JDK installed. To run WebLogic, you must have a domain. Luckily WebLogic is mature enough to be very handy for DevOps operations, and has support for a scripting tool called WLST (you guessed: WebLogic Scripting Tool), based on Jython (Python for Java) that allows you to script any task that you'd perform through a wizard or the web interface, from installation to configuration to management to monitoring. I've shared some samples on the GitHub project and I'll cover a couple of them in this series of WebLogic on Docker, but for now, let's just create the basic, empty WebLogic Domain.

Go to the samples folder and access folder 1221-domain. When there, just simply perform:

$ cd docker-images/OracleWebLogic/samples/1221-domain
$ docker build -t 1221-domain .

This process is very fast, at least for this sample. Time may vary if your WLST for creating a domain performs more tasks. See the sample to have some ideas.

Starting WebLogic on Docker

You now have the image 1221-domain ready to be used. All you need to do is to call:

$ docker run -ti -p 8001:8001 1221-domain

And now you can access the Admin Console on http://localhost:8001/console.

Frequently Asked Questions, Part 1

- Can I write my own Dockerfiles and WLST scripts to install and create WebLogic?

A: absolutely! That is the entire idea of sharing these scripts. These are excellent pointers on what can be done, and how. But customers and users are free to come up with their own files. And if you have some interesting approach to share, please send to me at bruno dot borges at oracle dot com.

- Why is WebLogic Admin on port 8001 instead of default 7001?

A: Well, it is a sample. It is to show what configurations you can do. The environment variable ADMIN_PORT, as well other configurations in the samples/1221-domain/Dockerfile are picked up by the script while creating the domain. The WLST script will even use some defaults if these variables are not defined. Again, it's a sample.

- What if I need to patch the WebLogic install?

A: you do that by defining a new Dockerfile and apply the patch as part of the build process, to create a new base image version. Then you recreate your domain image that extends the new patched base image. You may also want to simply extend your existing domain image, apply the patch, and use that one, or you can also modify your image by applying the patch in some existing container, then committing the container to a new image. There are different ways to do that, but for sure applying the patch to a live container is not one of them, since it is a good idea to keep containers as disposable as possible, and you should also have an image from where you can create new patched containers.

- What if I want a WebLogic cluster with Node Manager and Manged Servers?

A: that works too. I'll cover that in this series.

- Can I build a Docker image with a deployed artifact?

A: yes. More on that in upcoming blog posts of this series.

- Can I have a Load Balancer in front of a Swarm of Docker containers?

A: yes. That will also be covered as part of this series.

I hope you are excited to learn more about WebLogic on Docker.
So please follow this blog and my Twitter account for upcoming posts.

Thursday Jun 11, 2015

JavaOne, Oracle OpenWorld, e JUG Tour Brasil 2015

As palestras selecionadas para o JavaOne Brasil, e também para o Oracle OpenWorld Brasil, foram publicadas no site. O catálogo pode ser visto nos links abaixo:

Além de centenas de palestras, o evento contará também com 2 laboratórios práticos por dia, sobre diferentes temas como Java EE, JavaFX, e Java SE 8. Aqueles que adquirirem os pacotes do JavaOne poderão se inscrever sem custo adicional aos Hands-On Labs. Também teremos o NetBeans Day, no dia 22 de Junho durante todo o dia com diferentes palestras sobre desenvolvimento em Java e Cloud com a plataforma NetBeans. Para fechar toda a programação, encontros em mais de 15 JUGs por todo o Brasil também acontecerão, com palestras de speakers nacionais e internacionais, durante o 20 Days of Java Brazil JUG Tour 2015. Confira no site se o seu JUG faz parte do tour, e inscreva-se!

Inscreva-se no JavaOne!

Sunday May 31, 2015

Trip Report: Porto Tech Hub 2015

Porto Tech Hub is a new initiative by the city of Porto, in Portugal. A smart and very well organized and combined effort between the local Government and companies to push forward the Technology Industry in the region. And I was extremely happy to be part of this. The conference happened for one and a half day, and you can see by the Program that it held different topics, enabling and feeding the community with many different areas of interest.

The City of Porto is amazing. It was my first time in Portugal, and I must be thankful for you all people, or else I wouldn't exist. Second, I lived in Rio de Janeiro for 4 great years (now back in Sao Paulo though), so when I arrived in the region of Ribeira I found myself again in Rio by feeling the great atmosphere and seafood gastronomy. Whenever you go to Porto, make sure you go to the wineries to taste Port Wine (brought a few bottles back home)

I delivered the session Tweet for Beer - Beertap Powered by Java Goes IoT, Cloud, and JavaFX. Watch this demonstration if you don't know what's this about. It was fun to deliver a session in Portuguese outside Brazil. I did doublecheck with the audience if they could understand me, since Brazilian Portuguese is not exactly the same thing (Spanish though is different! Talking to you Americans... :-)

PS: after I delivered the session, I found out I was supposed to speak in English, since all speakers even the locals, were speaking English. I guess I got too excited with the idea of speaking with Portuguse audience :-)

The conference also had the presence of the awesome Christoph Engelbert (@noctarius2k) from Hazelcast, talking about In-Memory Distributed Computing. Dude, thanks for being an awesome travel companion, and for the two first pictures above.

Mensagem aos Amigos Lusitanos!

Obrigado a todos da organização pelo carinho especial, principalmente à Silvia e ao Jorge. Fui muito bem recebido e assistido por todos os envolvidos no evento. Muito legal também a participação da audiência durante a live demo do Tweet4Beer, enviando tweets e ganhando cervejas fictícias! E estou ansioso pela próxima edição. Sucesso a todos e até 2016!

Friday Nov 28, 2014

Oracle Linux Docker Base Image on Ubuntu 14.10

Oracle Linux team has been working hard to provide Docker support. You will be glad to see that they, since August, are releasing Docker binaries in Oracle Linux YUM repositories. Now recently they are also publishing the Oracle Linux Docker Base Images for OL6 and OL7! The documentation of Oracle Linux (OL6 and OL7) and Docker is also well advanced and explanatory. Keep track of everything about Docker and Oracle Linux from this yum page.

And why is this important you may ask? Well because it's definitely a required step if at some point the Fusion Middleware product teams move forward in certifying their products, such as WebLogic, on Docker as well. So if you want to work with Oracle products on Docker right now, although yet not certified nor supported, make sure you use the OL base images.

As a developer, I like to use Ubuntu Linux on my laptop. To use the OL7 Docker Base Image for example, I had to follow the following very short and easy steps:

  1. Make sure you have Docker installed on your Ubuntu environment

  2. Download the OL7 Base Image.

  3. Uncompress the file first with xz. You may find an issue where docker can't find the xz binary.
    $ sudo docker load -i oraclelinux-7.0.tar.xz
    2014/11/28 18:36:08 Error: Untar exit status 1 exec: "xz": executable file not found in $PATH

    $ unxz oraclelinux-7.0.tar.xz

  4. Load the image in your local Docker repository, as root, after extracting with xz (but keeping tar)
    $ sudo docker load -i oraclelinux-7.0.tar

  5. Check installation
    $ sudo docker images
    oraclelinux    7.0  5f1be1559ccf   2 weeks ago    265.2 MB

  6. Create and run a container based on this image
    $ sudo docker run -t -i oraclelinux:7.0 bash
Now have fun with Docker and Oracle Linux, and let me know if you create something cool with Fusion Middleware products!

Monday Oct 20, 2014

The Developers Conference 2014

Chegou ao fim a edição 2014 do The Developers Conference, com a última parada em Porto Alegre, que aconteceu entre os dias 16 e 18 de Outubro. E colocando na conta as cidades de Florianópolis, com 4 dias de evento no mês de Maio, e São Paulo com 5 dias de evento no mês de Agosto, a participação da Oracle no evento contou com 23 palestras de 15 papers em 12 trilhas, realizadas com muito empenho e dedicação por 5 palestrantes da Oracle.

A Oracle esteve presente nas seguintes trilhas de cada cidade:

Florianópolis - 15 a 18 de Maio  São Paulo - 5 a 9 de Agosto Porto Alegre - 16 a 18 de Outubro
Internet of Things  Internet of Things  Internet of Things
 Java  Arquitetura Java  Java University
 SOA & BPM  NoSQL  Mobile
 Games  Cloud  Cloud & DevOps
 Javascript  Javascript  Javascript
 Java EE  Java EE  Java EE

Fotos da participação da Oracle no TDC 2014

The Developer's Conference 2014 Florianopolis Edition
The Developer's Conference 2014 São Paulo
The Developer's Conference 2014 Porto Alegre

Palestras dos mais diversos assuntos, sempre alinhados com Padrões Abertos e Open Source. Veja abaixo todo o material apresentado pela Oracle no The Developers Conference 2014.

Palestras apresentadas

Foi sem dúvida, a maior participação da Oracle já registrada no TDC! E fica aqui meu muito obrigado aos amigos Marco Maciel, Denis Abrantes,  Fernando Ribeiro, e Giovani Bassan, que completaram o time de palestrantes desta edição. Todas as fotos do evento você pode encontrar diretamente nos álbums do próprio #TDC2014 no Facebook! Separei algumas fotos da Oracle no TDC 2014 Florianópolis, e que venha TDC2015!

Valeu pessoal!

JavaOne 2014 - Java Is What Java Does

Sunday Sep 21, 2014

WebLogic Encrypt Tool Script for Remote and Cloud Servers

One of the upcoming offerings of Oracle Java Cloud Service is a fully manageable instance of Oracle WebLogic in the Cloud. The service allows customers to manage a full instance of WebLogic the way they want. To do some tasks though, customers must connect through SSH to the server. Since security is important to us, WebLogic server is running Production Mode, and thus developers and operators are by default not allowed to use plain text passwords when executing WLST scripts, or deploying artifacts such as JDBC resources containing such plain text sensitive informations (you know... like... passwords!).

I've created this script to facilitate the encryption, and I'm quite sure it will be very useful to those Cloud operators and developers, but also for On Premise deployments where plain text passwords shouldn't be stored around on scripts and XML files. 

1 2 3 4 5 6 7 8 9 10 11 12 13 14
# Util script to encrypt a password on a remote WebLogic domain through SSH
DIR="$( cd "$( dirname "$0" )" && pwd )"

Let me know what you think! 

Monday Jun 30, 2014

Docker, Java EE 7, and Maven with WebLogic 12.1.3

UPDATE January 2016 - We now officially certify and support WebLogic 12.1.3 and WebLogic 12.2.1 on Docker Containers! For more information see this blog post and this whitepaper on OTN. The Docker configuration files are also now maintained on the official Oracle GitHub Docker repository. WebLogic 12.2.1 is also Java EE 7 and JDK 8 certified. Links in the Docker section of this article have also been updated to reflect the latest updates and changes.

For more up to date information on Docker scripts and support, check the Oracle GitHub project docker-images.

WebLogic 12.1.3 was released and with it the support for perhaps the most important Java EE 7 APIs for database-backed Web Applications development. These are the specifications supported in this release:
As you can see above, WebLogic is bundled with the same implementations used by GlassFish 4.0, which gives you a compatible application server if you have already started developing Java EE 7 applications (well, of course limited to these APIs) and now seek for a commercially supported environment.

There are also some improvements in the Apache Maven Plugin, which makes developers' life much easier, allows for much better automated testing (Arquillian!), Continuous Integration and Delivery. IDEs that support Maven-based projects also benefit from this.

Does this makes WebLogic the best Java EE application server to run modern web HTML5/Javascript applications with RESTful and WebSockets services? Sure yes! So to give you a great way to test WebLogic, I created a Dockerfile for you to in order to create a WebLogic domain on your development environment to test it as you wish. Go to the OracleWebLogic for the Developer ZIP Distro Dockerfile on the Official Oracle GitHub repository for Docker images.

Getting started with WebLogic 12.1.3, Java EE 7, Maven, and Docker

Now let's get it started. First go to and download WebLogic 12.1.3 ZIP Distro for Developers. Save that file for later use.

Installing WebLogic 12.1.3 without Docker (easy)
WebLogic ZIP is very easy to install:
  1. Extract the content in a folder where you want to hold the wls12130 directory that comes inside the ZIP file. On my Linux machine, I use /home/bruno/Work/tools/.
  2. Go to the wls12130 folder and run the configure.cmd (Windows) or (Unix).
    • Creating the domain may take too long and may be seen as the installer is freezed. Make sure to configure this if you are on Linux:
      $ export
  3. When the installer asks you if you want to create a domain, type [Y]
  4. Installer will ask you for username/password. On dev environments, I usually use weblogic/welcome1
  5. Installer will start WebLogic right away and you can check it running at http://localhost:7001/console

Installing WebLogic 12.1.3 with Docker (easier)

If you work on a Linux-based machine as your development environment and you aren't familiar with Docker yet, check the What is Docker, then give it a try. Long story short: Docker is a Linux container; it is like a virtual machine, but it is not (there are people running Docker on top of Vagrant virtual machines, for example). The most important thing for us here is that it will create a virtual network interface with a virtual IP address.

My laptop runs Ubuntu 14.04, so I used this Docker Installation Instruction to set it up. I will assume you will have Docker installed on your computer somehow, following instructions for your own operational system.
  1. Download the ZIP or checkout the docker-images Git repository and extract somewhere on your computer. I will use $DOCKER_HOME as a reference to that location.
  2. Copy the you download previously into $DOCKER_HOME/docker-images/dockerfiles/12.1.3
  3. Call the ../ script (as sudo) and wait for Docker to do its magic
  4. Call docker run -p 8001:8001 oracle/weblogic:12.1.3-developer and see WebLogic going up and running on a Docker container. 
    • It will attach port 8001 to your host interfaces
  5. Open http://localhost:8001/console. Username/password are weblogic/welcome1

Configuring your local Maven repository

It is now possible to use Maven without a local installation of WebLogic, which is perfect for CI environments (Hudson/Jenkins). You will still require a installation though to set up the Maven Plugin initially, but as soon you install this to your remote Maven repository for example, other developers and CI envs won't need to have WebLogic installed locally, if deploying to a remote server. For local development, you can also point to WebLogic as a "remote" server, of course. 

The steps to configure Maven are well documented and it is done by the Maven Synchronization Plug-in. After installing it to your local repository, you can call the sync goal to populate a local or remote repository. Here are the steps for a local environment:
  1. Go to the WebLogic home installation directory. For example:
    $ cd /home/bruno/Work/wls12130/
  2. Go to the subdir
    $ cd oracle_common/plugins/maven/com/oracle/maven/oracle-maven-sync/12.1.3/
  3. Execute the following command:
    $ mvn install:install-file -DpomFile=oracle-maven-sync-12.1.3.pom -Dfile=oracle-maven-sync-12.1.3.jar
  4. Finally you call the push command to upload all Maven artifacts (plugins, archetypes, etc) to your repository (local in this case)
    $ mvn -DoracleHome=/home/bruno/Work/wls12130/
If you want to setup a remote repository, check the documentation.

Create Java EE applications with WebLogic Maven Archetypes

WebLogic provides a set of archetypes that come with the Maven Plug-in pre-configured. Let's create a simple Web project by using the Basic WebApp Maven Archetype
mvn archetype:generate
Now of course you can open this Maven project on your NetBeans, IntelliJ IDEA, Eclipse, and then setup WebLogic in your IDE. Or you can just issue the command below to build, package, and deploy this WAR artifact to the WebLogic server you have running on your computer (either using Docker or the normal installation):
mvn package pre-integration-test 
Here we make sure to use -Dupload=true since I'm not sure if you are using Docker or not. If you are, then upload is required since the container has no access to your local file system (although possible!)

Description of wls_02.jpg follows

Now open http://localhost:7001/basicWebapp and see this sample application up and running!


By the way if you are an IntelliJ IDEA user you may want to watch this recent Webinar I did with JetBrains team: Developing Java EE Applications for WebLogic 12c with IntelliJ IDEA. The slides are available as well:

Check Bruno Borges slideshare repository

Wednesday May 14, 2014

Oracle no #TDC2014 Florianópolis

Este ano a presença da Oracle no The Developers Conference 2014 - Edição Florianópolis vai fazer a diferença! Sem contar que fomos até mencionados pelo Cacau Menezes, grande figura da região da Ilha da Magia. Vejam só o que ele disse em seu blog:
"Já pensou em controlar uma torneira de chopp via dispositivos móveis e ser avisado pelo Twitter quando você já tomou todas? Pois é, essa ideia se tornou realidade pelos profissionais da gigante tecnológica Oracle Bruno Borges (@brunoborges) e Marco Antonio Maciel (@marcomaciel)." - Cacau Menezes

Enfim, estaremos presente no evento com as seguintes palestras e trilhas:

Trilha Games - Quinta
15:40 - Como criar o game 2048 em JavaFX

Trilha Javascript - Quinta
17:40 - Nashorn: novo motor Javascript no Java

Trilha Java EE - Sexta
10:10 - Criando uma aplicação HTML5 com Java EE 7 e WebSockets

Trilha SOA & BPM - Sexta
15:40 - Integrando Oracle BPM com Java EE e WebSockets

Trilha Java - Sábado
10:10 - Migrando de Applets para JavaFX, e novos modelos de distribuição de aplicativos Java

Trilha Internet das Coisas - Domingo
15:40 - Controle de Eventos em Tempo Real através de Java Embarcado
17:40 - Tweet para cerveja! Torneira de chopp controlada por Java, JavaFX, e IoT!

Se você quiser saber mais sobre os palestrantes da Oracle que estarão presentes no evento, acompanhe o Giovani Bassan, o Marco Maciel, e o Bruno Borges (eu) no LinkedIn :-) E acompanhe no Twitter com a hashtag #TDC2014!

Este post foi originalmente publicado em Just Blogging by Bruno Borges

Wednesday Mar 26, 2014

Migrating JDBC Resources from GlassFish to WebLogic

Following up with my series of articles about Migrating from GlassFish to WebLogic, this time I want to cover the migration of a very common resource used by every Java EE developer: JDBC resources, or simply, DataSources. And in case you haven't read yet the first article, here it is: Migrating a Java EE App from GlassFish to WebLogic. That one will walk you through redeploying a simple yet almost complete Java EE 6 application on WebLogic, without any code change nor specific deployment descriptors, and still taking advantage of the enhanced Maven Plugin in WebLogic 12c.

It is easy to migrate resources by using the Web consoles of both WebLogic and GlassFish. Just open one browser window for each server, put them side-by-side, and follow the UI menus. Most of the properties are the same. But if you walkthrough the full article below, you will not only learn the concepts and what is required to migrate JDBC resources, but also how to migrate things using Command-line Interface (asadmin from GlassFish; wlst from WebLogic). So in order to understand what I'm doing here, I strongly recommend you to read, at least the introduction of, these two docs below in case you are not familiar with asadmin or wlst:

Oracle WebLogic Types of JDBC Data Sources

WebLogic offers three types of DataSources. For this migration, the type we will use will be "Generic". To know more about each type, click on the links below:

  • Generic Data Source
    • the type you are most familiar with; we will focus on this one
  • GridLink Data Source
    • in case you have an Oracle RAC Database, this is an optimal data source with HA and Failover features
  • Multi Data Source
    • abstracts two or more Generic Data Sources; works like a 'pool of data sources' so you can use it for either failover or load balancing

JDBC Resources: DataSources and Connection Pools

In the first article this was sort of covered from a Java EE Standard point of view. I simply took advantage of the @DataSourceDefinition annotation type, which allows developers to define JDBC DataSources directly from the Java source code, and requires no vendor-specific deployment descriptors nor manual previous configuration of the application server.

Now in case you have a legacy application or you are not using @DataSourceDefinition, you will be required to migrate these resources by hand. This will require three (plus one optional) simple steps:

  1. List JDBC resources from a GlassFish domain
  2. (optional; see below) Install 3rd-party JDBC drivers in WebLogic
  3. Extract and convert relevant and required information by WebLogic
  4. Create datasources inside WebLogic
Oracle WebLogic 12c already comes with JDBC drivers for Oracle DB 11g, MySQL 5.1.x, and Derby DB, so you won't need to do anything for these databases. For more information, read the docs JDBC Drivers Installed with WebLogic Server. In this doc you will also learn how to update the versions already provided by WebLogic, for example if you want to take advantage of the new features in Oracle DB 12c

If you are using Microsoft SQL Server, PostgreSQL, or any other database, check the Setting the Environment for a Thirdy-Party JDBC Driver for more information on how to install these drivers.

Concepts of JDBC Resources

We should also learn one difference between the concept of JDBC Resources in GlassFish 3 versus WebLogic 12c. In GlassFish, there are two types of JDBC Resources:
  • JDBC Connection Pools
  • JDBC Resources (aka DataSources)
On the other hand, WebLogic treats JDBC Resources as one single thing: Data Sources. The connection pool is part of the data source definition where in GlassFish, the Data Source is a separate artifact, which allows enabling/disabling the object, and also provides the JNDI name to a specific Connection Pool. In few words, when migrating a data source from GlassFish to WebLogic, you will only care about the JDBC Connection Pool and the JNDI name given at the JDBC Resource item.

Listing JDBC Resources from a GlassFish domain

First, let's list all JDBC Resources (datasources) in our GlassFish server. Connect with asadmin and execute thelist-jdbc-resources command:

asadmin> list-jdbc-resources
Command list-jdbc-resources executed successfully.

Let's focus on our example: the jdbc/gf2wls datasource. This will be the DataSource we will migrate from GlassFish to WebLogic. Now let's list all Connection Pools in this GlassFish domain by using asadmin list-jdbc-connection-pools:

asadmin> list-jdbc-connection-pools
Command list-jdbc-connection-pools executed successfully.

Now of course in case you have dozens of connection pools created in your GlassFish domain, it would be easier to issue a command that shows you which connection pool is associated to the Data Source you want to migrate. To do this, let's use the asadmin get command:

asadmin> get resources.jdbc-resource.jdbc/gf2wls.*

We not only got which connection pool is associated to this data source but also its JNDI name, because the name of the resource may not be exactly the same as the JNDI name. 

Extracting GlassFish's JDBC Connection Pool data

Next step is to get all properties of your Connection Pool. Let's issue the asadmin get command again:

asadmin> get resources.jdbc-connection-pool.mysql_gf2wls_gf2wlsPool.*
Command get executed successfully.

Easy, isn't? Now, let's focus on the minimum required properties we need to create this DataSource in WebLogic 12c. They are under* , so if you want to list only these, change the asadmin method above to the following: asadmin get*

Create the Data Source in WebLogic using WLST

To help you witht he final step, I've created a sample WLST script to create a Data Source in WebLogic. In this script, there are a few variables you must define. To call this script, go to your WebLogic installation directory and, if you are on Linux, call $ source (or the proper script for your environment). Then execute the WLST script: $ java weblogic.WLST

You should see the following output:

$ java weblogic.WLST
Initializing WebLogic Scripting Tool (WLST) ...

Welcome to WebLogic Server Administration Scripting Shell

Type help() for help on available commands

Connecting to t3://localhost:7001 with userid weblogic ...
Starting an edit session ...
Started edit session, please be sure to save and activate your 
changes once you are done.
Saving all your changes ...
Saved all your changes successfully.
Activating all your changes, this may take a while ... 
The edit lock associated with this edit session is released 
once the activation is completed.
Activation completed

That's it. Check your WebLogic Console, by going to the Data Sources page.

Extending and improving the migration process

Now you may be wondering how to improve the process by automating everything, right? Yes you can do that! Since we have been using CLI commands, it all depends now on you by tweaking and coding some bash scripts. For example, you can use asadmin to get the information of all Data Sources, generate a bunch of files, usesed to, you know, hack the output files, then loop through them and call a more dynamic WLST script. If you want to read files from WLST, here's a fragment you can use:

from import FileInputStream

propIS = FileInputStream("")
configDS = Properties()


Migrating Advanced Settings

If you want to migrate advanced settings of the Connection Pool, take a look at the full list of properties I extracted from GlassFish in my sample Data Source. To change for example the Max Pool Size, tweak the WLST script and add the following:


cd('/JDBCSystemResources/' + dsName + '/JDBCResource/' + dsName + '/JDBCConnectionPoolParams/' + dsName)

Again, you can do whatever you want in WLST.

There you go! If you come up with a super awesome script to automate the whole process, let me know!

Monday Mar 03, 2014

Migrating a Java EE App from GlassFish to WebLogic

WebLogic is Oracle's strategic application server for the Java EE Platform. Since Oracle decided to focus on it for commercial support, and decided to leave GlassFish free of any ties with commercial decisions, I decided to bring this type of content to help GlassFish customers as well users to experiment, try, and evaluate Oracle WebLogic 12c (Java EE 6 certified).

But before getting down to the migration part, first thing you should learn is How to Install WebLogic 12c. For this migration tutorial in a developer environment, we will be using the Developer installation, but for production environments, we recommend the Full installation.

Full Installation
For full installation that can be used either in a production environment or in a developer environment, download the WebLogic Generic Installer and follow the steps descriped in the documentation for 12.1.2 on how to install WebLogic.

The difference between full and dev, is that full is targeted for any environment, and dev is well, for developers only. Oracle always recommend the full installation, but usually and specially for Java EE applications in a dev environment, the Development installation is enough. The good thing about it is the download size: less than 200Mb, and still you also get Oracle Coherence to play with. By the way, there is no licensing requirements for development purposes (either full or dev install), because WebLogic (and other Oracle products) are free for developers.

Required software

For this series of Migrating from GlassFish to WebLogic, I will be using NetBeans 8.0, GlassFish JDK 7, Oracle MySQL Community 5.6, and WebLogic 12.1.2. So make sure you have that software (except WLS for now) installed and configured in your system.

Developer Installation of WebLogic 12c

Let's get started by first installing WebLogic 12c for Developers. Instructions here are for Linux, but it is not that much different for Windows or Mac.
  1. Download WebLogic 12c ZIP Distribution for Developers (latest version: 12.1.2)
  2. Unzip it somewhere, for example:
    $ unzip -d /opt
  3. Go into the newly created directory
    $ cd /opt/wls12120
  4. Let's unpack the JAR files that were optimally compressed with pack200
    $ sh    // for Windows, call configure.cmd
  5. After the uncompression, configure script will ask you if you want to create a new domain. Say "yes" by pressing 'y', then [enter]
  6. Provide a username, a password, and then confirm again the password
  7. Wait for the domain to be created and started
In just a few minutes you will have WebLogic installed, configured, and running!

Test your WebLogic 12c Developer Installation

At this point, you should have a WebLogic domain configured, up, and running. You can access the Admin Web Console at the following URL: http://localhost:7001/console. It will ask for username/password you typed during install. Take a moment to explore the Admin Console. You can find more information at the official documentation for 12.1.2.

You may also find very useful to know you can manipulate all domain settings through the WebLogic Scripting Tool, a command-line interface for you to code in Python, and issue commands to view and edit all settings. In an upcoming version of WebLogic we will also provide a REST interface.

I will use WLST in the next posts in this series, so maybe you want to read more later.

How to Start/Stop WebLogic 12c

In order to start and stop correctly your WebLogic domain, you can either do that from an IDE such as NetBeans, or by running specific scripts. These scripts are located under the following path location:

  • $ sh
  • $ sh

The Beauty of Java EE 6

Now, instead of going through the process of creating a Java EE application, I coded a small application that covers a large set of Java EE 6 APIs and pushed it to this GitHub repository. It is an application using the following APIs:
  • CDI 1.0
  • JSF 2.1
  • Bean Validation 1.0
  • EJB 3.1
  • JPA 2.0
  • JAX-WS 2.2
  • JAXB 2.2
  • JAX-RS 1.1
The beauty of Java EE is that you will learn from this migration how good it is when you follow standards, and also the value of the platform. Simply put: we will migrate this application without touching any code. At least not for now. Let's first set some infrastructure requirements. For now, we must have a database.

JPA and Database setup

To facilitate things, and before you can run this application, make sure you have MySQL installed and running onlocalhost, and with a database named gf2wls with username/password gf2wls with all privileges. The project comes with a drop-and-create configuration when JPA (through EclipseLink) is initialized.

To setup this, connect as root to your local MySQL server and issue the following two commands:
  1. $ mysql -u root -p
  2. mysql> create database gf2wls;
  3. mysql> grant all privileges on gf2wls.* to gf2wls@localhost identified by 'gf2wls';
And you are set!

Import project to NetBeans, setup MySQL driver, and run it on GlassFish

Since this is an article about migrating from GlassFish to WebLogic, I will assume you know how to get this application running on GlassFish from NetBeans. But I will provide some highlights to make it work smoothless.

In order for the @DataSourceDefinition entry inside class InitializeSampleDataSessionBean work fine and connect to your MySQL database in GlassFish, make sure you have copied MySQL JDBC Driver into glassfish3/glassfish/domains/domain/domain1/lib/ext/ of course, before starting it up. In WebLogic, you don't need to do this since MySQL Connector/J is already part of the default installation.

Download the project 'bookmark-javaee6' to your local machine by either cloning the GitHub repository locally, or by downloading the zip and extracting somewhere. This is an Apache Maven project, so don't worry about environment. Just make sure you have this project up and running on a GlassFish domain.

Import the project bookmark-javaee6 into your NetBeans environment. Right click on bookmark-javaee6 project and select Run. Test the application by going to http://localhost:8080/bookmark-javaee6.

You should by now looking at the following screen:

Test the Bookmark WebService with a simple client

The sample Bookmark application comes with a JAX-WS WebService.

  1. You can test this WebService in many ways, but I will give you three main options: one is to try SoapUI
  2. Another option is to right click on the WebService in NetBeans, and select Test WebService
  3. Last option is to run the bookmark-javaee6-wsclient that comes with JUnit Test Cases. 
Make your choice, and see it working!

Running the sample Java EE 6 application in WebLogic 12c

Before we go to a pure Maven description on how to do this, let's give NetBeans a try. Now that you have everything ready (a Java EE 6 application running on GlassFish, with source code as a Maven project in NetBeans, let's add WebLogic as a Server to it.

  1. Go to the Services tab in NetBeans, and right click in Servers, then select Add Server....
  2. Select Oracle WebLogic Server
  3. Insert the path location of your recently installed WebLogic server. Remember to select the subfolderwlserver. If you installed as described in the beginning, you should try /opt/wls12120/wlserver
  4. Type your username and password of your WebLogic domain
  5. Finish this wizard
Now we must change from GlassFish to WebLogic in Project Properties. Select bookmark-javaee6 project and right click on it. Go to Run and select your newly created WebLogic 12.1.2 server. Press OK. See the picture below to understand what has to be done:

Start your project by right clicking in it, and select Run! Test your application running on WebLogic by going to the following location: http://localhost:7001/bookmark-javaee6

In case you had any problem, try these two articles:

Success! You have now the same application running on WebLogic 12c! Without any code change!

WebLogic understands GlassFish Deployment Descriptor

I haven't mentioned this before because I wanted you to see the sample application up and running on WebLogic, but what you can do in this application is to remove src/main/webapp/WEB-INF/weblogic.xml, and change the context-root inside glassfish-web.xml. What will happened if you redeploy this application without weblogic.xml, is that the application will start just fine, but in a different context-root: the one you typed inside glassfish-web.xml.

The reason for this is well documented on Support for GlassFish Deployment Descriptors. Give it a look in case you want to know what else does WebLogic understands from GlassFish's DD.

Now, let's try something different. Let's now use pure Apache Maven to compile and run the application on your WebLogic installation! For that, we will first need to configure the plugin.

Configuring the WebLogic Development Maven Plugin

Before you can use the plugin, you must install it in your local or remote Maven repository. Feel free to follow official instructions for WebLogic 12.1.2. But in case you want to just get it done, here's the short version:

  1. Go to your WLS installation. It is probably located here:
  2. Now change to the following directory:
    $ cd oracle_common/plugins/maven/com/oracle/maven/oracle-maven-sync/12.1.2
  3. Issue the following command to sync WLS Maven Plugin into your local repository:
    $ mvn -Doracle-maven-sync.oracleHome=/opt/wls12120/oracle_home/.
You have now successfully installed WLS Maven Plugin. To validate the installation, type:
$ mvn help:describe -Dversion=12.1.2-0-0

To continue, let's configure the plugin onto our bookmark-javaee6 sample application, and then deploy the package into WebLogic
  1. Open the POM file of bookmark-javaee6 project
  2. Uncomment the WebLogic Maven Plugin definition
  3. Make sure to enter the same username and password as your domain when you installed and configured WebLogic
  4. Make sure WebLogic is running
  5. Make sure there's no other bookmark-jaavaee6 project deployed on your WebLogic instance
  6. Execute the following command:
    $ mvn package pre-integration-test
  7. Check your logs and try http://localhost:7001/bookmark-javaee6!


As you could see, if you are working with a Java EE 6 project 100% standardized, and perhaps Maven, you will find no problems at migrating this project to WebLogic 12c. In fact, if you are using Maven it will be as simple as adding a new plugin just to facilitate deployment. But even this you won't have to do in case you have a binary only. Just open the Admin Web Console, and fire a deployment from there!

And by the way, WebLogic is not that heavyweight and unproductive application server developers thought it still is. For more information about Developer Productivity with WebLogic 12c, read my entry "WebLogic in Comparison: RebelLabs and the Java App Server Debate".

Caveats for Java EE projects, road ahead for migrations

In the next blog posts of this series, I will cover how to work around some common issues when your project is not exactly following, or taking advantage of all standards defined in the Java EE 6 platform, or simply using extra features, customizations of GlassFish.

Here's a sneak peek of what's coming next:
  • How to Migrate JDBC DataSources from GlassFish to WebLogic
  • How to Define, Deploy, and Use JMS resources
  • How to Migrate JMS resources from GlassFish to WebLogic
  • How to Add and Isolate (classpath of) 3rd-party libraries (for example PrimeFaces)
And many more things to come!
  • Applying a GlassFish Domain Topology to a WebLogic Domain (clustering, etc)
  • Migrating Security Realms
  • Migrating Custom Login Modules
If there's any other subject you'd like to see, please post a comment!


Wednesday Jan 08, 2014

WebLogic in Comparison: RebelLabs Java Servers Report

RebelLabs did a great job comparing the main Java servers out there, where some are pure Servlet/JSP containers, others are full Java EE compliant. But they didn't want to include in the list Oracle WebLogic nor IBM WebSphere apparently for no logical reason but "they are suited for large enterprise production environments", and because the report is focused on developers.

"The Great Java Application Servers Debate"

So, I decided to write this blog post to include detailed information about WebLogic, since WLS is free for developers, even if you are going to deploy GlassFish/JBoss/Whatever in production. Which is why I didn't get why RebelLabs didn't want to compare WebLogic.

Remember, I will detail WebLogic from a "developer point of view", using the same categories RebelLabs used in their report. Here we go:

Download & Installation

WebLogic 12c is certified for Java EE 6, and 12.1.1 was released on Dec 2011. The second release is 12.1.2 and is from July 2013, part of the full Cloud Application Foundation 12c release. For developers, there is a ZIP distribution sized at 184Mb.
  1. Accept Licence agreement
  2. Download installation package *
  3. Extract the archive
  4. Run (Linux/Mac) or configure.cmd (Windows)
  5. You are ready to go!
* you must have an OTN account, required for other things like access Oracle Forums

The script will ask you if you want to create a domain. Say "yes". Then you are asked to provide username/password for it, because we do care about default security. And right after the script finishes creating the domain, you can point to http://localhost:7001/console, because the script will automatically start WebLogic for you. To start WebLogic again, just call: 
$ cd user_projects/domains/mydomain; sh
Conclusion: License accepted only once. Bigger than others indeed but enhanced default security. Starts server automatically right after creating domain.

Tooling support

The RebelLabs report says WebLogic is only integrated with JDeveloper. But that's a big mistake. WebLogic is well integrated with NetBeans, Eclipse, IntelliJ, and can even be used with Apache Maven and Ant. For a "big fat bloated enterprise production-only app server", I would say WebLogic is in very good shape for development environments.

Eclipse: you can either download Oracle Enterprise Pack for Eclipse bundled with Eclipse, or just the update by either downloading the repository, or pointing to the repository URL.

NetBeans: support comes out of the box since version 7.1 (released in January 2012). Here's an article hosted on about NetBeans and WebLogic.

IntelliJ IDEA: Jetbrains comes with native support for WebLogic not only version 12, but also older versions. 

Apache Maven: in release 12.1.2, Oracle WebLogic has an enhanced Maven support with more goals and easier installation into Maven repositories. Check the documentation to learn more.

Apache Ant: for several versions WebLogic has been coming with Ant support. And continues to do so. Check the documentation for 12.1.2

If you are developing with Eclipse, NetBeans, or JDeveloper, you can even enable FastSwap, a feature that reloads changed classes on the fly. I've blogged about how to enable and use FastSwap with NetBeans a while ago.

Conclusion: has support for 99,9999% of tools used by developers. FastSwap for on-the-fly class update. IntelliJ and NetBeans with OOTB support. Eclipse plugin or full distribution with OOTB support.

Server Configuration

In the report, RebelLabs gave GlassFish a score of 3, which is weird because the way they described this section, seems like everything is perfect. The "Reason" line gives no negative reason at all! So I asked them on Twitter.

In WebLogic, you can basically do everything through the Web console available in the Admin Server. From there you can create clusters, create new managed servers, add Java EE resources like JMS queues, Data Sources. You can create Work Managers, do Security management. Anything. But for developers that don't want to follow steps documented in Word files full of screenshots of all these Web interfaces, they can simply write a Python script, and whenever they have to configure something [again], all they need to do is to run the script. The feature is calledWebLogic Scripting Tool, or simply WLST, and several companies have been using this for many years. It's great for configuration automation and also manageability. If you want to record the commands you type in the WLST shell for future executions, call startRecording(). If you don't want to write a script from scratch, the Adminstration Web console comes with a "Recording" feature that will record all your actions and create the script for future executions. And you can also connect through JMX.

If you are really into XML configuration, you can access the domain folder, then edit theconfig/config.xml file and do your magic. But they will only take effect after a restart.

And finally, most changes don't require a server restart.

Conclusion: Python scripts. JMX. Rich web console. Recording features. XML. Most changes go live without restart.

Documentation & Community

Documentation for WebLogic is very complete, and the new 12.1.2 documentation website has an updated Look & Feel. It is easy to navigate and comes with a search (basic and advanced) feature. The community is not as small as you may think. Oracle runs the Oracle ACE program and highlights outstanding professionals all around the world. The Oracle Partner Network is also big, with several folks running meetings, bootcamps, hackathons, etc. Take for example the last edition of UK OUG Tech 13, where attendees developed Puppet modules during a WebLogic Hackathon. And finally there's an Oracle Forum for WebLogic which is ran by the Oracle Technology Network team. 

Community is not related to only Open Source products. Doesn't matter if it's Open Source or not, if there's enough people working with a product, there's a chance for a community be born.

Conclusion: There is a community. Not as know as Open Source ones. Widespread around the world. Decentralized.

Features & Open Standards compliance

WebLogic 12c is Java EE 6 Full profile certified. Customers can also develop rich web applications with Oracle ADF, and they also get extra features/support for TopLink, like Oracle Coherence Integration. TopLink can be seen as an extension of EclipseLink, the Open Source JPA implementation, maintained at the Eclipse Foundation, but with great contribution from Oracle. WebLogic 12c has also support for OSGi bundles.

For administrators and devops, in addition licensed customers gain several other products and support. So for example, if you are comparing WebLogic Standard Edition with JBoss, don't forget that WLS SE comes bundled with support for: 
  • Oracle HTTP Server (enhanced Apache)
  • Oracle TopLink/ADF
  • Configuration Wizard / Upgrade Framework / OPatch
  • Oracle Java SE
  • Oracle WebLogic Management Framework
  • WebLogic JDBC Drivers, Server Clients, Apache Plugin
  • HTTP Pub-Sub Server
If you want more details about what you get by buying WebLogic, see this table. It will show also what other flavours of WebLogic (Enterprise/Suite) have to offer.

Conclusion: of course 1 apple will be cheaper than 4. :-)

Conclusion: Java EE 6 and OSGi. Extra features/products for licensed customers starting since WebLogic Standard Edition. Most complete application server, with support for all products involved in a basic infrastructure for running server-side Java applications.

Administration & Management/UI

As I pointed in the "Server Configuration", WebLogic has several ways for the developer to configure whatever the dev wants. But to give you an impression, here's a screenshot of the Admin Console, to create a JDBC Data Source:
Conclusion: Rich web console. Allows to control, from the Admin Server, all resources, as well monitor and manage servers in one or more clusters.

Cost $$$ / Licensing

The pricelist is available publicly and can be easily googled. No secrets, full transparency, from how much you pay (at maximum, since there's always a conversation with the sales rep), to what you get in exchange. Remember: when you license and contract support for WebLogic Standard Edition, you pay per processor socket (not per core), and you get support for Oracle Java SE (JVM), Oracle HTTP Server (Apache), and several other features/products. Other editions are priced differently but come with even more features.

But anyway, WebLogic comes with no charge for developers.

Conclusion:  When comparing cost to other application servers, remember that WebLogic comes with supported JVM (Oracle HotSpot), support of an enhanced Apache (Oracle HTTP Server), and other things that most application servers don't offer when you license or subscribe for support.

The Results

I've seen developers running Tomcat or JBoss or GlassFish, and going into production with WebSphere or WebLogic. But with the information above, I say that, overall,  WebLogic has evolved a lot especially in the new 12c version, with a smaller ZIP distribution, easy and secure installation, enhanced Maven support, great features for managing, awesome tooling support, and most important, free for developers. And don't forget the community! 

If a developer wants to develop pure Java EE applications, WebLogic is a very strong candidate. Even if the customer is running WebSphere in production :-)

Tuesday Jan 07, 2014

Demoiselle Framework no WebLogic 12c

Pra quem não sabe, o Demoiselle é um framework que roda sob a plataforma Java EE 6, desenvolvido e mantido pelo SERPRO para ser usado em projetos de todas as esferas do Governo.

No dia 1 de Novermbro do ano passado (2013), foi lançada a versão 2.4.0 conforme o Twitter dos mantenedores do framework. Decidi então saber qual seria a dificuldade de rodar um projeto Demoiselle no Oracle WebLogic 12c.

O WebLogic 12c (versão 12.1.1) foi lançado em Dezembro de 2011 e é compatível e certificado na plataforma Java EE 6, mas foi no ano passado em Julho que recebeu um update (a versão 12.1.2) com uma série de novas features e algumas correções, completando assim o release 12c do Cloud Application Foundation, que serve de infraestrutura para toda a tecnologiaFusion Middleware da Oracle.

Criando um projeto de exemplo e um pacote WAR

Uma grande vantagem do Demoiselle é que é um framework desenvolvido inteiramente com Apache Maven, e possui archetypes para facilitar a criação de novos projetos. Para este teste, vou usar o seguinte archetype:
O comando para criar um projeto a partir deste archetype pode ser este:
$ mvn archetype:generate \ \
 -DarchetypeArtifactId=demoiselle-jsf-jpa \
 -DarchetypeVersion=2.4.0 \ \
-DartifactId=demoiselle-sample-2.4.0 \
 -Dversion=1.0.0-SNAPSHOT \
O nome do projeto será demoiselle-sample-2.4.0

Ajuste a configuração JPA do projeto

O Demoiselle vem com um arquivo persistence.xml no diretório src/main/resources/META-INF e este arquivo deve ser editado da seguinte maneira: 
  1. Comente a configuração que está ativa logo no início do arquivo (específica para JBoss)
  2. Descomente a segunda configuração para GlassFish, chamada "GlassFish 3 with JTA transaction"
  3. Modifique o JNDI do Data Source para o seguinte valor: jdbc/demoiselle

Geração do pacote WAR

Agora para ter um arquivo WAR pronto para ser instalado no WebLogic, basta gerar o pacote: 
$ mvn -Pglassfish3 package
Repare que especifico o profile chamado glassfish3. Isto porque o Demoiselle possui uma série de profiles para cada servidor de aplicação (tomcat6, tomcat7, glassfish3, jboss6, jboss7). No momento em que escrevo este blog, meu pedido para acrescentar o profile do WebLogic 12c ainda não foi aceito. Acompanhe o pull request no GitHub para maiores detalhes e atualizações.

Mas não tem problema especificar o profile já existente glassfish3, pois este atende às especificações do Java EE 6, e o WAR resultante funciona perfeitamente no WebLogic 12c. 

Agora você deve ter no diretório target do projeto, um arquivo chamado demoiselle-sample-2.4.0-1.0.0-SNAPSHOT.war. Anote o local e o nome deste arquivo para depois fazermos deploy deste artefato.

Download, Instalação, Configuração e Deploy no WebLogic 12c

Sobre como fazer download e como instalar o WebLogic, já escrevi em 2012, How to Install WebLogic 12c ZIP on Linux (em inglês). Se tiver alguma dúvida, comente no post!

Quanto à configuração, a única coisa que precisamos fazer é criar um Data Source apontando para um banco de dados. Desde a versão 10.3.3 o WebLogic já vem com o Derby como parte da instalação, permitindo assim configurar um Data Source para um banco de dados em memória. No WebLogic 12c, o Derby já está ativo e para criar um Data Source é bem fácil.

Primeiro, acesse o diretório onde o domínio foi criado, e depois inicialize o servidor:
$ ./
Agora acesse a URL do console administrativo Web no endereço http://localhost:7001/console. Informe o usuário/senha que você definiu durante a instalação (geralmente, é weblogic/welcome1). O passo-a-passo da configuração é bem simples:
  1. No menu esquerdo, clique em Services, Data Sources
  2. Clique no botão New
  3. Selecione a opção Generic Data Source
  4. Informe o valor jdbc/demoiselle nos dois campos texto (Name e também JNDI Name)
  5. Selecione o tipo de banco de dados Derby na combobox
  6. Clique em Next
  7. Na tela seguinte não há o que fazer. Clique em Next
  8. Na tela seguinte também não há o que fazer. Clique em Next
  9. Na tela onde diz "Connection Properties", informe o valor demoiselle no campo Database Name
  10. Nesta tela, informe localhost como o Host Name
  11. Nesta tela, informe demoiselle nos campos Username, Password, Confirm Password
  12. Clique em Next
  13. Na tela seguinte verifique os dados, e experimente a configuração clicando no botão Test Configuration
  14. Clique em Next
  15. Selecione o AdminServer e finalmente, clique em Finish
Agora você deve ter um Data Source chamado jdbc/demoiselle, de acordo com a configuração feita anteriormente no persistence.xml do projeto.

WLST - WebLogic Scripting Tool

O WebLogic vem com uma feature muito legal chamada WLST, que permite você escrever scripts em Python para automatizar tarefas administrativas no servidor de aplicação. Se você achou o passo-a-passo acima complicado, experimente rodar este script especificamente para criar o Data Source jdbc/demoiselle usando o Derby. O procedimento é simples:
  1. Faça download do arquivo no Gist
  2. Acesse a pasta do domínio WebLogic
  3. Digite o seguinte comando para incorporar as variáveis de ambiente do domínio WebLogic na shell:

    $ source bin/

  4. Digite o seguinte comando para invocar o script:

    $ java weblogic.WLST <caminho para o arquivo>/

Deployment da aplicação Demoiselle

Aproveitando o ambiente do domínio na sua shell (após executar "source bin/"), é muito simples fazer o deploy da aplicação. Execute o seguinte comando:
$ java weblogic.Deployer \  -username weblogic \  -password welcome1 \  -deploy <caminho para o projeto>/demoiselle-sample-2.4.0/target/demoiselle-sample-2.4.0-1.0.0-SNAPSHOT.war
Lembre-se de ajustar o usuário e senha do seu domínio WebLogic tanto no comando acima, quanto no script WLST. Por conveniência, deixei já o comumente utilizado u:weblogic p:welcome1.

Caso queira usar a interface Web, o processo é simples. Clique no menu Deployments, depois no botão Install e basta seguir as instruções da tela.

Testando a aplicação Demoiselle

Agora que a aplicação está rodando, você pode testar acessando a URL da aplicação, que provavelmente é esta: http://localhost:7001/demoiselle-sample-2.4.0-1.0.0-SNAPSHOT/index.jsf

Qualquer dúvida, é só comentar! Ou me procurar no Twitter @brunoborges. :-)



Thursday Dec 05, 2013

WebLogic agora é grátis para desenvolvedores!

Uma ótima notícia, que não é mais tão notícia assim, para todas as empresas desenvolvedoras de software, ISVs, fábricas de software, parceiros e não-parceiros Oracle. O WebLogic, servidor de aplicação Java EE líder de mercado pode ser baixado gratuitamente e utilizado em ambientes de desenvolvimento sem qualquer custo, através da licença da OTN. Conforme licença publicada no site, o trecho mais importante é este:

"[...] deploy the programs only on your single developer desktop computer (of any type, including physical, virtual or remote virtual), to be used and accessed by only (1) named developer."

Até então era comum acreditar que para desenvolver para uma grande empresa que adquiriu o WebLogic, seria necessário a empresa prestadora de serviço adquirir também o produto. Um exemplo comum é de empresas que desenvolvem software para outras empresas em forma de projetos (fábricas de software); estas empresas podem utilizar o WebLogic nas máquinas dos desenvolvedores sem qualquer custo Outro trecho interessante na licença da OTN é este:

"You may continue to develop, test, prototype and demonstrate your application with the programs under this license after you have deployed the application for any internal data processing, commercial or production purposes"
Veja a licença OTN completa para maiores informações

Se a sua empresa está em São Paulo, e vocês desenvolvem software para outras empresas que utilizam o WebLogic em produção, entre em contato para conhecer mais sobre o novo Oracle WebLogic 12c: bruno dot borges at oracle dot com.

Se ainda restam dúvidas sobre a simplicidade de instalar o WebLogic em ambientes de desenvolvimento, veja este outro blog post (em inglês) sobre como configurar o WebLogic distribuído em formato ZIP: How To Install WebLogic Zip on Linux!


Bruno has been having fun working with Java since 2000 and now helps Oracle on sharing the technology accross all Latin America. Also plays videogames, does trekking and loves beer.

Follow me on Twitter! @brunoborges


« May 2016