Customer Reviews

GlassFish Administration

5 star:		(2)
4 star:		(3)
3 star:		(2)
2 star:		(0)
1 star:		(0)

 

 

Book Review of "GlassFish Administration", Packt Publishing

(A reprint from the original article [...])

This book is meant to be a resource for users of the GlassFish application server. It covers many aspects of GlassFish use, including installation, configuration, application deployment, clustering, performance monitoring, and more. I would believe this book is appropriate for Enterprise Java administrators of all experience levels.

The book is generously illustrated, often times making use of screen shots to help users navigate the excellent GlassFish administrative UI. Better yet, the book also provides the Command Line equivalents wherever the UI is shown. These handy tips will allow experienced administrators to script installations, significantly cutting down both time and errors.

The CLI tips are just one example of the author's mastery of advanced server control issues. The author, Xuekun Koum, clearly understands the needs of enterprise server administrators and clearly spells out many best practices. For this reason, I would recommend this book for anyone planning to use GlassFish in a production environment. The chapters on performance tuning, monitoring, and security alone will make this book worthwhile for that audience.

In addition to that audience, I would also recommend this book to Enterprise Java developers who wish to keep abreast of best coding practices for the Java EE platform. Have you ever seen a coding demo given by Sun engineers? Using Netbeans and GlassFish, they are usually able to quickly generate flawless Java EE applications using mostly plain intuitive Java. (No hand-configuration of deployment descriptors!) This book, paired with a recent release of Netbeans and "Java EE 5 Development using GlassFish Application Server" (another Packt title) will allow you to knowledgeably generate Enterprise Java applications as easily as the Sun folks do. I'll be honest-- I'm usually not a NetBeans/GlassFish user, but this combination makes it drop-dead simple to generate entire applications in no time. Best of all, the generated source and configuration files are so clean that it's a snap to understand what each component does so you can brush up on how the whole things works. GlassFish does it's part by nicely bundling all the required resources (databases, application server instances, JMS providers, etc.), making them all very easy to administer. I've long thought Microsoft developers had a leg up on productivity given their excellent IDE and matching runtime environment, but after working with this toolset for a while I now believe the gap is closing.

I own some other titles on application server administration as well as this one. Frankly, I find this the most readable of these books. The instructions it provides are straightforward and very easy to follow. The author provides expert insights that probably came from many hours of working with GlassFish in different production settings. (Some of these ideas extend beyond current use of GlassFish, as well. In this regard, the book provides some best practices that should give the reader some wisdom without having to pay for it the hard way.) This book also touches on topics that really aren't specific to GlassFish, but rather are of interest to anyone working with an application server. Of particular interest in this area are sections on application monitoring and load balancing.

As for complaints, I have few. The primary thrust of the book is GlassFish 2, which is the current production mainstay. There is a chapter on GlassFish 3, but I wish the book were weighted a little more heavily towards version 3 so the book would maintain relevance longer. (In fairness to the author, I guess it's not possible to offer real-world experienced opinions on products that haven't been in use for much time. So I guess the version 2 / version 3 ratio is about right, realistically.) I wish this title contained a little of the content from some of Packt's other developer-centric titles (i.e. Netbeans tips). Other than those, I can't think of any other wants.

All things considered, this is a solid addition to any Java architect/developer's library. I'd urge you to check it out!

"Glassfish Administration" by Xuekun Kou is accurate, concise and useful.

Computer manuals comprise an odd segment of the publishing industry. I suppose that this is because the books published in this segment generally have both a narrowly defined audience and scope and a short window of usefulness driven by the speed of evolution of the products they seek to address. This, sadly, seems to result in books of this kind falling into two general categories: Sparse works that cover little more than what the end user could have found in the product's install documentation or its included "readme" files and at the other extreme heavy tomes of dense material that make it difficult for the product end user to zero in on the essential information they require to address their immediate administration needs.

So, when I had been invited to review "GlassFish Administration" from Packt I was predisposed to believe that Mr. Kou's book would suffer from the same flaws as so many other system administration books: too short to be of use to anyone but those who are brand new to the product or of use to someone interested in becoming an expert in all nuances of the product. "Glassfish Administration" deviates from this pattern. I was pleased to find that Mr. Kou had written a well balanced handbook for Glassfish that addressed much of what is essential for making good use of what I consider to be an excellent product.

The book may also serve as a "bridge" manual for Glassfish development and production teams. This is to say that the book could be a useful tool to quickly get both your development teams and production teams to understand the platform and its capabilities from the same perspective with a minimum of fuss, regardless of where you project is in its development cycle. Many of us that use Glassfish are first exposed to the product as it is bundled with an IDE, typically Netbeans. What we find in Glassfish is a platform that, along with its associated development tools, is an excellent development platform that is pre-configured for a workstation environment in order to meet the needs of the developer. This is certainly a plus for the developer trying to get their code running but less than optimal for the administrator who will be responsible for the day to day "care and feeding" of the application as its deployed in the server stack.

For example, Kou's discussion of the alternate releases (pure open source release vs. the commercially supported release ) of the application server along with illustrations their different abilities and behaviors in a production environment along with chapters like "Configuring Clusters and High Availability" are useful for both the developer and administrator alike. If you are a project lead for a Glassfish application this material should be considered a prerequisite for all team members as your project enters its systems planning and pre-production phases. Misunderstandings and mis-communications at these stages can have the potential to drive expensive re-design changes back to developer which can be expensive. Use of Mr. Kou's book as "team support materials" or "bridge materials" at these stages may help mitigate this kind of risk.

"Glassfish Administration" also presents a pleasant physical product. The book is well formatted, topics flow logically and its use of fonts and screen shots is clear and consistent. Formatting that is "easy on the eyes" is, for someone who spends many hours looking and computer screens and reading programming and systems manuals, something that is appreciated in a book of this kind. Packt has done a nice job on this aspect of the product.

If you are looking for well written and balanced handbook in support of your Glassfish installation or application development project Xuekun Kou's "Glassfish Administration" needs to be on your short list of titles to consider.

Let's start from what I expected of the book. I'm JEE application developer who had some experience with two different JEE application server products. I always got to know different administrating tasks as I needed them. First my colleagues showed me how to handle very basic tasks so I could test my code and further explore administration console on my own. Then as I needed features like application security, access control, shared code, details about particular resource configuration I searched for solutions and tutorials on the web. Finally I decided that I should learn what is there readily available for me and what are the concepts behind it. That is why I decided to read this book.
Unfortunately, the book wasn't the answer. I wish I had it two years ago as I started my adventure with JEE. It is a set of basic step-by-step tutorials concerning main aspects of JEE server administration. The book assumes no prior knowledge of the topic. I would recommend it to a newbie in the area who has to or wants to tackle JEE server by himself. It can serve as a set of tutorials (colleague') that will help you to install GlassFish, show where to find administrative tools, help you navigate administration console, teach basic administration tasks and get you started.
What I liked about the book was that it starts with a chapter on server architecture before introducing any task and that every chapter starts with some kind of a architecture, problem, concepts overview with a diagram if possible. The explanations are very concise. If you didn't know anything about security, container architecture, messaging systems etc. you probably won't be an expert after reading two pages with basic definitions or big-picture components communication diagram but it will give you context to help you understand why does a particular task involve this many steps and why these steps are needed. Another thing I liked was that there was full command-line listings for every task and authors encouraged to use command-line administration console which is not that hard to learn but far more powerful than web-console. I also enjoyed these few tips from authors' experience and that they pointed to the most interesting, according them, open-source projects used in GlassFish server and useful tools for monitoring and troubleshooting.
There were also things I didn't like. In the first chapter there were screenshots of almost every step of the installation process, even if they didn't bring anything. The last chapter with GlassFish 3 overview, except of very little information on what's new in this version, contained detailed instructions on how to install GlassFish 3 and how to deploy applications to it although it was almost copy & paste of the information in previous chapters. For me they were not worth reading. Also there were too little tips from the authors. More advanced topics were only mentioned, which is good for a getting started book, but was a flaw for me.
I would recommend this book to total newbie who needs detailed instruction on how to start and a set of step-by-step tutorials on every topic in GlassFish administration. A person with little more experience will be rather disappointed as the book contains only very detailed (too detailed) instructions on basic tasks with only a few sections just naming more advanced topics.

I was offered the opportunity to review the GlassFish Administration book by Xuekun Kou from Packt Publishing. The book focuses on GlassFish version 2.1.1, but does have some coverage of version 3 (V3). The book is a smaller digest of a number of books published by Oracle (Sun) and the GlassFish document team.

The book breaks down into ten chapters on version 2.1.1, and an eleventh chapter on version 3. I am not sure where I stand on this book. I really don't like references to certain features in the table of contents which would lead you to believe it has some depth on the subject. Later you discover that it refers you to the actual "official" publications I noted above. I think that if you give it a sub-chapter designation, it must actually have some depth. I really found the book to cover most of the subjects in a shallow manner.

My other pet peeve is when code is included (or not included) in a book which does not work, or is shallowly offered without explanation. For example, there is a code example for security, but no explanation, or setup instructions. The other issue is where the book refers to the code, but it does not exist in the format in the book. There are numerous examples of this as you will note below.

If you have gotten this far in my review, you must wonder if the book has any redeeming value. Yes, it does. As an experienced GlassFish administrator, there are a lot of topics that are covered in too little detail for me, but as a new administrator, the book is a good starting place. I was expecting more advanced coverage of some topics, but this is material for a book on Advanced GlassFish Administration. This book offers would be GlassFish administrators a look into all the functionality that it offers.

I would give it a 3/5 stars for advanced administrators. This book is a very good book for starting administrators which probably should be 3.5/5 stars.

Chapter one covers the basic installation which is no real surprise. The information is essentially the same as found on the GlassFish project web site. There is a nice section on how to do silent installs which is not really covered on the site.

Chapter two is a high-level overview of the server architecture. This is where the book shines. The information and illustrations are great. The author has done a great job covering the architecture with very good explanations.

The third chapter provides the reader with information on the application deployment capabilities of GlassFish. The explanation on the ease of development functionality is very good. It covers items like dynamic reload and command-line deployment options. This is a good introduction to the CLI portion of GlassFish which makes it easy to script for your particular OS. This chapter also includes installing JRuby and Grails based applications. The Grails example is really cool and worked like a champion.

The fourth chapter covers container configuration and basic services. I believe that the section on configuring HTTP listeners should have been covered prior to virtual servers because of the dependency. This chapter is very shallow. It shows you how to configure these services from both the Admin Console and CLI, but gives really nothing in way of explanation of the options available.

The fourth chapter concludes with a confusing explanation of the Application Client Container. It seems very out of place and should be re-written with a code example.

Chapter five discusses how to configure (JNDI) resources within GlassFish. This is a very important topic. The author does a good job of explaining how to configure the various resources from JDBC to external JNDI resources. There are not too many good examples on how to configure external resources. There are a number of command-line example errors, but fortunately GlassFish really does a great job of making correction suggestions.

Chapter six covers JMS specifically Open MQ and Apache ActiveMQ. It is really well done and covers an import aspect of modern application servers. The asynchronous transaction is becoming more important especially when combined with AJAX technologies which allow web applications to continue to respond to user input while actions are occurring in the background. This chapter also covers the imqadmin console.

One of the best aspects of chapter six is its coverage of Apache ActiveMQ. I prefer to use Open MQ (included in GlassFish), but the chapter shows how to integrate external JMS resources into GlassFish. GlassFish includes a generic JMS JCA adapter which is used to integrate Apache ActiveMQ.

Chapter seven covers security and securing GlassFish. I was disappointed that there were no examples of client certificate authentication. I was also disappointed that the only coverage on certificates was based on self-signed, and there was absolutely no coverage of NSS security. The Java ACC support is incomplete especially without an example. The only really redeeming section in the chapter was the use of password aliases fro encrypting application resources.

Monitoring is covered in chapter eight. The basics of how to setup the monitoring are covered. There is no significant depth to the chapter. The discussion on call flow monitoring shows an example of an application which is not included in the sample code. It is from the Java EE tutorial (Duke's Bank). The chapter does topically demonstrate additional monitoring tools like JConsole and VisualVM. Both of these tools are included in the JDK, and don't get the coverage they deserve. VisualVM is a NetBeans platform application.

The chapter closes with Enterprise Manager, but refers you to external references. I was not impressed. It should have not even made mention of it, if there was no coverage.

Clustering and High Availability (HA) is covered in chapter nine. I liked chapter nine in general. The explanation of the clustering functionality: node agents, and instances was very good. The author explains in detail how to install the load balancer which needed some detail coverage. The information available online is not very centralized. The explanation on in-memory replication including diagrams is very good. It also explains replication ring and some issues with that are encountered on adjacent instance failures.

HADB should be removed from chapter nine. There is no coverage worth mentioning, and it should have been a cornerstone of the chapter.

Chapter ten covers troubleshooting and performance tuning. Actually that is the title, but it really does not cover performance tuning. The reference is to a commercial support contract Performance Advisor. That being said, it does cover some additional functionality of tools like VisualVM and introduces jstack. It also covers the Thread Dump Analyzer (TDA) and NetBeans profiler.

Chapter eleven is a topical coverage of GlassFish version 3. It was not finalized at the time of release of this book. The information is generally correct though and will give the reader important aspects of the new release and its capabilities.

Summary

The overall impression of the book was a modest 3/5 stars. The book would be a good starting point for a new administrator, but lacks sufficient detail for an advanced practitioner. If you are looking for a beginning book on GlassFish administration, this is not a bad choice.

Additional notes and my personal errata are on my blog (...)

I purchased the book last week. Read through Chapter 1 - 3 (Getting started, Architecture, Managing apps)in a day. Then Finished Chapter 4 - 6 (Configure Service, Configure Resources, JMS Resources) this week.
I am especially happy with the clear instruction that I can follow. (This is no Bulls..t talking, simply technical)

The book covers materials in a balance that it talks about important things and leaves some redundant things to software document.

I don't know if there are a lot of people using GlassFish these days. But if you do, this is a book that you must have on your self.

I have been programming Java for 14 years.

We recently had a project that envolved GlassFish. I bought the book because I had never used GlassFish before. It took me about 3 days to follow the book from begining to end and now I am comfortable with GlassFish server.

The goodness about the book is that it talks all important aspects and keeps things simple at the same time. Good job!

I've recently been invited to review "GlassFish Administration" from Packt and I happily accepted the offer. Page after page and my happiness was steadily vanishing. I think it's my last book about administration of Java EE application servers from Packt. Their books are very easy to read and I've always been enjoying their reading, but when it comes to their value as a source of information on the real administration they fall short. They simply don't provide the value I expect.

The book "GlassFish Administration" made no difference. This book described very little about advanced administration stuff like scripting or those features that place GlassFish as the solution of choice, and to me it's yet another book for GlassFish newbies. I'd only recommend it for those who haven't yet had a slightest chance to play with GlassFish (or you've got plenty of time and the book's on your shelf ready for a ride). If you're busy and you want to learn the GlassFish intricacies, make no mistake about it - you won't learn much.

The author Xuekun Kou and the book's reviewers had first reassured myself that the book would bring some additional value other than describing the most basic stuff, but it took no more than 4-5 chapters before I scratched my head wondering why I was still reading it. It was boring most of the time. It takes a few chapters and you've no doubts about the author's practical GlassFish administration experience yet he decided to showcase available features without their in-depth explanation. The book should've been titled "Review of available GlassFish v2 features for administrators". Would you buy this book if you hit the title on the shelf with Java EE books? I wouldn't.

Fortunately, I found some hidden gems. I liked the sections "Configuring virtual servers" and "Request processing process" in the chapter 4, the section "Naming references and binding information" in the chapter 5 with its eye-opener - a figure that illustrates the process of resolving resource references, chapter 6. "Configuring JMS Resources" where the author discussed configuration of Open MQ and Apache ActiveMQ with GlassFish, the chapter 8. "Monitoring GlassFish" in which I learned about Call Flow, and read a little bit about JConsole and VisualVM, and the most rewarding chapter 9. "Configuring Clusters and High Availability" in which I discovered that GlassFish is capable of providing HA and failover environment I thought only IBM WebSphere Application Server (WAS) could. GlassFish and WAS become very close to each other as far as the enterprise configuration goes. I have never considered GlassFish as a viable competitor to WAS, but with the chapter 9. of the book I'm willing to accept contrary opinions. It was hardly the case before. I didn't know about silent installation of GlassFish either. There's a section (solely a page) about it too. It should've been longer.

The book is all about GlassFish 2.1.1 with the last chapter 11. "Working with GlassFish 3" aiming to bring v3 to the masses. That was the idea I guess, but I hardly believe anybody could think of it as such, as it's just a copy of the book's first chapters with only few parts GlassFish v3-related. I wish it'd described a bit more details about GlassFish v3's new OSGi-based architecture, not too mention its Java EE 6 support.

The writing style made the reading very pleasant and the lack of more advanced administration tasks significantly diminished its value. It could've been better with more examples and without sections about features like JACC with only two paragraphs (!) The administration commands executed from within the GlassFish Administration Console as well as from the command line provided exceptional learning experience. I did like it. It was one of the very few technical books where Unix commands were the primary ones executed.

The book wasn't that bad after all, but if you're looking for a book about GlassFish real-life administration, "GlassFish Administration" will not be nearly enough.