Monday Oct 22, 2012

Ops Center 12c - Update - Provisioning Solaris on x86 Using a Card-Based NIC

Last week, I posted a blog describing how to use Ops Center to provision Solaris over the network via a NIC on a card rather than the built-in NIC.  Really, that was all about how to install Solaris on a SPARC system.  This week, we'll look at how to do the same thing for an x86-based server.

Really, the overall process is exactly the same, at least for Solaris 11, with only minor updates. We will focus on Solaris 11 for this blog.  Once I verify that the same approach works for Solaris 10, I will provide another update.

Booting Solaris 11 on x86

Just as before, in order to configure the server for network boot across a card-based NIC, it is necessary to declare the asset to associate the additional MACs with the server.  You likely will need to access the server console via the ILOM to figure out the MAC and to get a good idea of the network instance number. 

The simplest way to find both of these is to start a network boot using the desired NIC and see where it appears in the list of network interfaces and what MAC is used when it tries to boot.  Go to the ILOM for the server.  Reset the server and start the console.  When the BIOS loads, select the boot menu, usually with Ctrl-P.  This will give you a menu of devices to boot from, including all of the NICs.  Select the NIC you want to boot from.  Its position in the list is a good indication of what network number Solaris will give the device.


In this case, we want to boot from the 5th interface (GB_4, net4).  Pick it and start the boot processes.  When it starts to boot, you will see the MAC address for the interface

Once you have the network instance and the MAC, go through the same process of declaring the asset as in the SPARC case.  This associates the additional network interface with the server..

Creating an OS Provisioning Plan

The simplest way to do the boot via an alternate interface on an x86 system is to do a manual boot.  Update the OS provisioning profile as in the SPARC case to reflect the fact that we are booting from a different interface.  Update, in this case, the network boot device to be GB_4/net4, or the device corresponding to your network instance number.  Configure the profile to support manual network boot by checking the box for manual boot in the OS Provisioning profile.

Booting the System

Once you have created a profile and plan to support booting from the additional NIC, we are ready to install the server. Again, from the ILOM, reset the system and start the console.  When the BIOS loads, select boot from the Boot Menu as above.  Select the network interface from the list as before and start the boot process.  When the grub bootloader loads, the default boot image is the Solaris Text Installer.  On the grub menu, select Automated Installer and Ops Center takes over from there.

Lessons

The key lesson from all of this is that Ops Center is a valuable tool for provisioning servers whether they are connected via built-in network interfaces or via high-speed NICs on cards.  This is great news for modern datacenters using converged network infrastructures.  The process works for both SPARC and x86 Solaris installations.  And it's easy and repeatable.

Tuesday Oct 16, 2012

Ops Center 12c - Provisioning Solaris Using a Card-Based NIC

It's been a long time since last I added something here, but having some conversations this last week, I got inspired to update things.

I've been spending a lot of time with Ops Center for managing and installing systems these days.  So, I suspect a number of my upcoming posts will be in that area.

Today, I want to look at how to provision Solaris using Ops Center when your network is not connected to one of the built-in NICs.  We'll talk about how this can work for both Solaris 10 and Solaris 11, since they are pretty similar.  In both cases, WANboot is a key piece of the story.

Here's what I want to do:  I have a Sun Fire T2000 server with a Quad-GbE nxge card installed.  The only network is connected to port 2 on that card rather than the built-in network interfaces.  I want to install Solaris on it across the network, either Solaris 10 or Solaris 11.  I have met with a lot of customers lately who have a similar architecture.  Usually, they have T4-4 servers with the network connected via 10GbE connections.

Add to this mix the fact that I use Ops Center to manage the systems in my lab, so I really would like to add this to Ops Center.  If possible, I would like this to be completely hands free.  I can't quite do that yet. Close, but not quite.

WANBoot or Old-Style NetBoot?

When a system is installed from the network, it needs some help getting the process rolling.  It has to figure out what its network configuration (IP address, gateway, etc.) ought to be.  It needs to figure out what server is going to help it boot and install, and it needs the instructions for the installation.  There are two different ways to bootstrap an installation of Solaris on SPARC across the network.   The old way uses a broadcast of RARP or more recently DHCP to obtain the IP configuration and the rest of the information needed.  The second is to explicitly configure this information in the OBP and use WANBoot for installation

WANBoot has a number of benefits over broadcast-based installation: it is not restricted to a single subnet; it does not require special DHCP configuration or DHCP helpers; it uses standard HTTP and HTTPS protocols which traverse firewalls much more easily than NFS-based package installation.  But, WANBoot is not available on really old hardware and WANBoot requires the use o Flash Archives in Solaris 10.  Still, for many people, this is a great approach.

As it turns out, WANBoot is necessary if you plan to install using a NIC on a card rather than a built-in NIC.

Identifying Which Network Interface to Use

One of the trickiest aspects to this process, and the one that actually requires manual intervention to set up, is identifying how the OBP and Solaris refer to the NIC that we want to use to boot.  The OBP already has device aliases configured for the built-in NICs called net, net0, net1, net2, net3.  The device alias net typically points to net0 so that when you issue the command  "boot net -v install", it uses net0 for the boot.  Our task is to figure out the network instance for the NIC we want to use. 

We will need to get to the OBP console of the system we want to install in order to figure out what the network should be called.  I will presume you know how to get to the ok prompt.  Once there, we have to see what networks the OBP sees and identify which one is associated with our NIC using the OBP command show-nets.

SunOS Release 5.11 Version 11.0 64-bit
Copyright (c) 1983, 2011, Oracle and/or its affiliates. All rights reserved.

{4} ok banner

Sun Fire T200, No Keyboard
Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
OpenBoot 4.30.4.b, 32640 MB memory available, Serial #69057548.
Ethernet address 0:14:4f:1d:bc:c, Host ID: 841dbc0c.

{4} ok show-nets
a) /pci@7c0/pci@0/pci@2/network@0,1
b) /pci@7c0/pci@0/pci@2/network@0
c) /pci@780/pci@0/pci@8/network@0,3
d) /pci@780/pci@0/pci@8/network@0,2
e) /pci@780/pci@0/pci@8/network@0,1
f) /pci@780/pci@0/pci@8/network@0
g) /pci@780/pci@0/pci@1/network@0,1
h) /pci@780/pci@0/pci@1/network@0
q) NO SELECTION 
Enter Selection, q to quit: d
/pci@780/pci@0/pci@8/network@0,2 has been selected.
Type ^Y ( Control-Y ) to insert it in the command line. 
e.g. ok nvalias mydev ^Y 
         for creating devalias mydev for /pci@780/pci@0/pci@8/network@0,2
{4} ok devalias
...
net3                     /pci@7c0/pci@0/pci@2/network@0,1
net2                     /pci@7c0/pci@0/pci@2/network@0
net1                     /pci@780/pci@0/pci@1/network@0,1
net0                     /pci@780/pci@0/pci@1/network@0
net                      /pci@780/pci@0/pci@1/network@0
...
name                     aliases

By looking at the devalias and the show-nets output, we can see that our Quad-GbE card must be the device nodes starting with  /pci@780/pci@0/pci@8/network@0.  The cable for our network is plugged into the 3rd slot, so the device address for our network must be /pci@780/pci@0/pci@8/network@0,2.

With that, we can create a device alias for our network interface.  Naming the device alias may take a little bit of trial and error, especially in Solaris 11 where the device alias seems to matter more with the new virtualized network stack. So far in my testing, since this is the "next" network interface to be used, I have found success in naming it net4, even though it's a NIC in the middle of a card that might, by rights, be called net6 (assuming the 0th interface on the card is the next interface identified by Solaris and this is the 3rd interface on the card).  So, we will call it net4.  We need to assign a device alias to it:

{4} ok nvalias net4 /pci@780/pci@0/pci@8/network@0,2
{4} ok devalias
net4                     /pci@780/pci@0/pci@8/network@0,2
...

We also may need to have the MAC for this particular interface, so let's get it, too.  To do this, we go to the device and interrogate its properties.

{4} ok cd /pci@780/pci@0/pci@8/network@0,2
{4} ok .properties
assigned-addresses       82060210 00000000 03000000 00000000 01000000 
                         82060218 00000000 00320000 00000000 00008000 
                         82060220 00000000 00328000 00000000 00008000 
                         82060230 00000000 00600000 00000000 00100000 
local-mac-address        00 21 28 20 42 92 
phy-type                 mif
...

From this, we can see that the MAC for this interface is  00:21:28:20:42:92.  We will need this later.

This is all we need to do at the OBP.  Now, we can configure Ops Center to use this interface.

Network Boot in Solaris 10

Solaris 10 turns out to be a little simpler than Solaris 11 for this sort of a network boot.  Since WANBoot in Solaris 10 fetches a specified

In order to install the system using Ops Center, it is necessary to create a OS Provisioning profile and its corresponding plan.  I am going to presume that you already know how to do this within Ops Center 12c and I will just cover the differences between a regular profile and a profile that can use an alternate interface.

Create a OS Provisioning profile for Solaris 10 as usual.  However, when you specify the network resources for the primary network, click on the name of the NIC, probably GB_0, and rename it to GB_N/netN, where N is the instance number you used previously in creating the device alias.  This is where the trial and error may come into play.  You may need to try a few instance numbers before you, the OBP, and Solaris all agree on the instance number.  Mark this as the boot network.

For Solaris 10, you ought to be able to then apply the OS Provisioning profile to the server and it should install using that interface.  And if you put your cards in the same slots and plug the networks into the same NICs, this profile is reusable across multiple servers.

Why This Works

If you watch the console as Solaris boots during the OSP process, Ops Center is going to look for the device alias netN.  Since WANBoot requires a device alias called just net, Ops Center uses the value of your netN device alias and assigns that device to the net alias.  That means that boot net will automatically use this device.  Very cool!  Here's a trace from the console as Ops Center provisions a server:

Sun Sun Fire T200, No Keyboard
Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
OpenBoot 4.30.4.b, 32640 MB memory available, Serial #69057548.
Ethernet address 0:14:4f:1d:bc:c, Host ID: 841dbc0c.

auto-boot? =            false
{0} ok  
{0} ok printenv network-boot-arguments
network-boot-arguments =  host-ip=10.140.204.234,router-ip=10.140.204.1,subnet-mask=255.255.254.0,hostname=atl-sewr-52,client-id=0100144F1DBC0C,file=http://10.140.204.22:5555/cgi-bin/wanboot-cgi
{0} ok
{0} ok devalias net
net                      /pci@780/pci@0/pci@1/network@0
{0} ok devalias net4
net4                     /pci@780/pci@0/pci@8/network@0,2
{0} ok devalias net /pci@780/pci@0/pci@8/network@0,2
{0} ok setenv network-boot-arguments host-ip=10.140.204.234,router-ip=10.140.204.1,subnet-mask=255.255.254.0,hostname=atl-sewr-52,client-id=0100144F1DBC0C,file=http://10.140.204.22:8004/cgi-bin/wanboot-cgi
network-boot-arguments =  host-ip=10.140.204.234,router-ip=10.140.204.1,subnet-mask=255.255.254.0,hostname=atl-sewr-52,client-id=0100144F1DBC0C,file=http://10.140.204.22:8004/cgi-bin/wanboot-cgi
{0} ok
{0} ok boot net - install
Boot device: /pci@780/pci@0/pci@8/network@0,2  File and args: - install
/pci@780/pci@0/pci@8/network@0,2: 1000 Mbps link up
<time unavailable> wanboot info: WAN boot messages->console
<time unavailable> wanboot info: configuring /pci@780/pci@0/pci@8/network@0,2

See what happened?  Ops Center looked for the network device alias called net4 that we specified in the profile, took the value from it, and made it the net device alias for the boot.  Pretty cool!

WANBoot and Solaris 11

Solaris 11 requires an additional step since the Automated Installer in Solaris 11 uses the MAC address of the network to figure out which manifest to use for system installation.  In order to make sure this is available, we have to take an extra step to associate the MAC of the NIC on the card with the host.  So, in addition to creating the device alias like we did above, we also have to declare to Ops Center that the host has this new MAC.

Declaring the NIC

Start out by discovering the hardware as usual.  Once you have discovered it, take a look under the Connectivity tab to see what networks it has discovered.  In the case of this system, it shows the 4 built-in networks, but not the networks on the additional cards.  These are not directly visible to the system controller.

 In order to add the additional network interface to the hardware asset, it is necessary to Declare it.  We will declare that we have a server with this additional NIC, but we will also  specify the existing GB_0 network so that Ops Center can associate the right resources together.  The GB_0 acts as sort of a key to tie our new declaration to the old system already discovered.  Go to the Assets tab, select All Assets, and then in the Actions tab, select Add Asset.  Rather than going through a discovery this time, we will manually declare a new asset.

When we declare it, we will give the hostname, IP address, system model that match those that have already been discovered.  Then, we will declare both GB_0 with its existing MAC and the new GB_4 with its MAC.  Remember that we collected the MAC for GB_4 when we created its device alias.

After you declare the asset, you will see the new NIC in the connectivity tab for the asset.  You will notice that only the NICs you listed when you declared it are seen now.  If you want Ops Center to see all of the existing NICs as well as the additional one, declare them as well.  Add the other GB_1, GB_2, GB_3 links and their MACs just as you did GB_0 and GB_4.

 Installing the OS

 Once you have declared the asset, you can create an OS Provisioning profile for Solaris 11 in the same way that you did for Solaris 10.  The only difference from any other provisioning profile you might have created already is the network to use for installation.  Again, use GB_N/netN where N is the interface number you used for your device alias and in your declaration.


 And away you go.  When the system boots from the network, the automated installer (AI) is able to see which system manifest to use, based on the new MAC that was associated, and the system gets installed.

{0} ok
{0} ok printenv network-boot-arguments
network-boot-arguments =  host-ip=10.140.204.234,router-ip=10.140.204.1,subnet-mask=255.255.254.0,hostname=atl-sewr-52,client-id=01002128204292,file=http://10.140.204.22:5555/cgi-bin/wanboot-cgi
{0} ok
{0} ok devalias net
net                      /pci@780/pci@0/pci@1/network@0
{0} ok devalias net4
net4                     /pci@780/pci@0/pci@8/network@0,2
{0} ok devalias net /pci@780/pci@0/pci@8/network@0,2
{0} ok setenv network-boot-arguments host-ip=10.140.204.234,router-ip=10.140.204.1,subnet-mask=255.255.254.0,hostname=atl-sewr-52,client-id=01002128204292,file=http://10.140.204.22:5555/cgi-bin/wanboot-cgi
network-boot-arguments =  host-ip=10.140.204.234,router-ip=10.140.204.1,subnet-mask=255.255.254.0,hostname=atl-sewr-52,client-id=01002128204292,file=http://10.140.204.22:5555/cgi-bin/wanboot-cgi
{0} ok
{0} ok boot net - install
Boot device: /pci@780/pci@0/pci@8/network@0,2  File and args: - install
/pci@780/pci@0/pci@8/network@0,2: 1000 Mbps link up
<time unavailable> wanboot info: WAN boot messages->console
<time unavailable> wanboot info: configuring /pci@780/pci@0/pci@8/network@0,2
...
SunOS Release 5.11 Version 11.0 64-bit
Copyright (c) 1983, 2011, Oracle and/or its affiliates. All rights reserved.
Remounting root read/write
Probing for device nodes ...
Preparing network image for use
Downloading solaris.zlib
--2012-02-17 15:10:17--  http://10.140.204.22:5555/var/js/AI/sparc//solaris.zlib
Connecting to 10.140.204.22:5555... connected.
HTTP request sent, awaiting response... 200 OK
Length: 126752256 (121M) [text/plain]
Saving to: `/tmp/solaris.zlib'

100%[======================================>] 126,752,256 28.6M/s   in 4.4s   

2012-02-17 15:10:21 (27.3 MB/s) - `/tmp/solaris.zlib' saved [126752256/126752256]

Conclusion

So, why go to all of this trouble?  More and more, I find that customers are wiring their data center to only use higher speed networks - 10GbE only to the hosts.  Some customers are moving aggressively toward consolidated networks combining storage and network on CNA NICs.  All of this means that network-based provisioning cannot rely exclusively on the built-in network interfaces.  So, it's important to be able to provision a system using other than the built-in networks.  Turns out, that this is pretty straight-forward for both Solaris 10 and Solaris 11 and fits into the Ops Center deployment process quite nicely.

Hopefully, you will be able to use this as you build out your own private cloud solutions with Ops Center.

Saturday Nov 05, 2011

Solaris 11 Launch - Wish I could be there

Wish I could be in NYC this week!  After being a part of the Solaris team for a long, long time, it's great to see this finally almost here.  

But, if you can be in NYC or catch the webcast, I hope you will.

Join Oracle executives Mark Hurd and John Fowler and key Oracle Solaris Engineers and Execs at the Oracle Solaris 11 launch event in New York, Gotham Hall on Broadway, November 9th and learn how you can build your infrastructure with Oracle Solaris 11 to:

    * Accelerate internal, public, and hybrid cloud applications
    * Optimize application deployment with built-in virtualization
    * Achieve top performance and cost advantages with Oracle Solaris 11–based engineered systems

The launch event will also feature exclusive content for our in-person audience including a session led by the VP of core Solaris development and his leads on Solaris 11 and a customer insights panel during lunch. We will also have a technology showcase featuring our latest systems and Solaris technologies. The Solaris executive team will also be there throughout the day to answer questions and give insights into future developments in Solaris.

Don't miss the Oracle Solaris 11 launch in New York on November 9.
REGISTER TODAY!

Oracle OpenWorld Session - Case Study: High-Performance Cloud Datastore Using Oracle Solaris 11 and Oracle Solaris ZFS

How's that for a long title?

Just a note that the slides are now available from our ZFS in the cloud session at OpenWorld.  Tom Shafron, CEO of Viewbiquity, and I presented on the new features in ZFS and how Viewbiquity is using them to provide a cloud-based data storage system.

From our abstract: Oracle Solaris ZFS, a key feature of Oracle Solaris, integrates the concepts of a file system and volume management capabilities to deliver simple, fast data management. This session provides a case study of Viewbiquity, a provider of market-leading, innovative M2M platforms. Its cloud-based platform integrates command and control, video, VoIP, data logging and management, asset tracking, automated responses, and advanced process automation. Viewbiquity relies on Oracle Solaris ZFS and Oracle Solaris for fast write with integrated hybrid traditional and solid-state storage capabilities, snapshots for backups, built-in deduplication, and compression for data storage efficiency. Learn what Oracle Solaris ZFS is and how you can deploy it in high-performance, high-availability environments.

Viewbiquity is doing some cool stuff with ZFS, so take a look at the slides (found here) to see how you, too, can use ZFS in some really cool ways.

Oracle OpenWorld Hands On Lab - Solaris 10 Patching with Live Upgrade

Finally getting around to posting this.  We had a great turnout for our Solaris 10 Patching with Live Upgrade hands-on-lab at OpenWorld a few weeks back.  

The lab was a self-guided tour through the basics of using Live Upgrade combined with ZFS root to seriously speed up the system maintenance process.  You can find the lab document here. Since this after the actual live lab, the document describes how to create a basic Solaris instance to use to practice patching.  Nothing special - just a basic Solaris 10 VM with ZFS for the root. 

The document also refers to applying patches that we supplied in the lab.  This was just a trimmed down set of the Recommended Patchset.  It was trimmed down just so the lab would fit within our alloted time, not for any functional reason.  So, grab the latest Recommended Patchset from MOS and just use that.

So, take a look at the lab guide.  Move toward using ZFS for the root and Live Upgrade for patching.  This is a huge benefit and a way that you can hours out of your planned maintenance time.

Friday Jul 29, 2011

How much does Live Upgrade patching save you? Lots!

For a long time, I have advocated that Solaris users adopt ZFS for root, storing the operating system in ZFS.  I've also strongly advocated for using Live Upgrade as a patching tool in this case.  The benefits are intuitive and striking, but are they actual and quantifiable?

Background

You can find a number of bloggers on BOC talking about the hows and whys of ZFS root.  Suffice it to say that ZFS has a number of great qualities that make management of the operating system simpler, especially when combined with other tools like Live Upgrade.  ZFS allows for the immediate creation of as many snapshots as you might want, simply by preserving the view of the filesystem meta-data and taking advantage of the fact that all writes in ZFS use copy-on-write, completely writing the new data before releasing the old.  The gives us snapshots for free.

Like chocolate and peanut butter, ZFS and Live Upgrade are two great tastes that taste great together.  Live Upgrade, traditionally was used just to upgrade systems from one release of Solaris (or update release) to another.  However, in Solaris 10, it now becomes a tremendous tool for patching.  With Live Upgrade (LU), the operating system is replicated in an Alternate Boot Environment (ABE) and all of the changes (patches, upgrades, whatever) are done to the copy of the OS while the OS is running, rather than taking the system down to apply maintenance.  Then, when the time is right, during a maintenance window, the new changes are activated by rebooting using the ABE. 

With this approach, downtime is minimized since changes are applied while the system is running.  Moreover, there is a fall-back procedure since the original boot environment is still there.  Rebooting again into the original environment effectively cancels out the changes exactly.

The Problem with Patching

Patching, generally speaking, is something that everyone knows they need to do, but few are really happy with how they do it.  It's not much fun.  It takes time.  It keeps coming around like clockwork.  You have to do it to every system.  You have to work around the schedules of the applications on the system.  But, it needs to be done.  Sort of like mowing the grass every week in the summer.

Live Upgrade can take a lot of the pain out of patching, since the actual application of the patches no longer has to be done while the system is shut down.  A typical non-LU approach for patches is to shut the system down to single-user prior to applying the patches.  In this way, you are certain that nothing else is going on on the system and you can change anything that might need to be updated safely.  But, the application is also down during this entire period.  And that is the crux of the problem.  Patching takes too long; we expect systems to be always available these days.

How long does patching take?  That all depends.  It depends on the number of changes and patches being applied to the system.  If you have not patched in a very long time, then a large number of patches are required to bring the system current.  The more patches you apply, the longer it takes.

It depends on the complexity of the system.  If, for example, there are Solaris zones on the system for virtualization, patches applied to the system are automatically applied to each of the Zones as well.  This takes extra time.  If patches are begin applied to a shut-down system, that just extends the outage. 

It's hard to get outage windows in any case and long outage windows are especially hard to schedule especially when the perceived benefit is small.  Patches are like a flu shot.  They can vaccinate you against problems that have been found, but they won't help if this year has a new strain of flu that we've not seen before.  So, long outage across lots of systems are hard to justify.

So, How Long Does It Really Take

I have long heard people talk about how patching takes too long, but I've not measured it in some time.  So, I decided to do a bit of an experiment.  Using a couple of different systems, neither one very fast or very new, I applied the Solaris 10 Recommended patch set from mid-July 2011.  I applied the patches to systems running different update releases of Solaris 10.  This gives different numbers of patches that have to be applied to bring the system current.  As far as procedure goes, for each test, I shut the system down to single-user (init S), applied the patches, and rebooted.  The times listed are just the time for the patching, although the actual maintenance window in real-life would include time to shut down, time to reboot, and time to validate system operation.  The two systems I used for my tests were an X4100 server with 2 dual-core Opteron processors and 16GB of memory and a Sun Fire V480 server with 4 UltraSPARC III+ processors.  Clearly, these are not new systems, but they will show what we need to see.

 System  Operating System
 Patches Applied
 Elapsed Time (hh:mm:ss)
X4100 Solaris 10 9/10
105
00:17:00
X4100 Solaris 10 10/09
166
00:26:00
X4100 Solaris 10 10/08
216
00:36:06
V480
Solaris 10 9/10 99 00:47:29


For each of these tests, the server is installed with root on ZFS and patches are applied from the Recommended Patchset via the command "./installpatch -d --<pw>" for whatever password this patchset has.  All of this is done while the system was in single-user rather than while running multi-user.

It appears that clock speed is important when applying patches.  The older V480 took three times as long as the X4100 for the same patchset.

And this is the crux of the problem.  Even to apply patches to a pretty current system requires an extended outage.  This does not even take into account the time required for whatever internal validation of the work done, reboot time, application restart time, etc.  How can we make this better?  Let's make it worse first.

More Complicated Systems Take Longer to Patch

Nearly a quarter of all production systems running Solaris 10 are deployed using Solaris Zones.  Many more non-production systems may also use zones.  Zones allow me to consolidate the administrative overhead of only having to patch the global zone rather than each virtualized environment.  But, when applying patches to the global zone, patches are automatically applied to each zone in turn.  So, the time to patch a system can be significantly increased by having  multiple zones.  Let's first see how much longer this might take, and then we will show two solutions.

System
Operating System
Number of Zones
Patches Applied
Elapsed Time (hh:mm:ss)
X4100
Solaris 10 9/10 2 105
00:46:51
X4100 Solaris 10 9/10 20
105
03:03:59
X4100 Solaris 10 10/09 2
166
01:17:17
X4100 Solaris 10 10/08 2
216
01:37:17
V480
Solaris 10 9/10 2
99
01:53:59

Again, all of these patches were applied to systems in single-user in the same way as the previous set.  Just having two (sparse-root) zones defined took nearly three times as long as just the global zone alone.  Having 20 zones installed took the patch time from 17 minutes to over three hours for even the smallest tested patchset.

How Can We Improve This?  Live Upgrade is Your Friend

There are two main ways that this patch time can be improved.  One applies to systems with or without zones, while the second improves on the first for systems with zones installed.

I mentioned before that Live Upgrade is very much your friend.  Rather than go into all the details of LU, I would refer you to the many other blogs and documents on LU.  Check out especially Bob Netherton's Blog for lots of LU articles.

When we use LU, rather than taking the system down to single-user, we are able to create a new alternate boot environment, using ZFS snapshot and clone capability, while the system is up, running in production.  Then, we apply the patches to that new boot environment, still using the installpatchset command.  For example, "./installpatchset -d -B NewABE --<pw>" to apply the patches into NewABE rather than the current boot environment.  When we use this approach, the patch times that we saw before improve don't change very much, since the same work is being done.  However, all of this is time that the system is not out of service.  The outage is only the time required to reboot into the new boot environment.

So, Live Upgrade saves us all of that outage time.  Customers who have older servers and are fairly out of date on patches say that applying a patch bundle can take more than four or five hours, an outage window that is completely unworkable.  With Live Upgrade, the outage is reduced to the time for a reboot, scheduled when it can be most convenient.

Live Upgrade Plus Parallel Patching

Recently, another enhancement was made to patching so that multiple zones are patched in parallel.  Check out Jeff Victor's blog where he explains how this all works.  As it turns out, this parallel patching works whether you are patching zones in single-user or via Live Upgrade.  So, just to get an idea of how this might help I tried to do some simple measurement with 2 and 20 sparse-root zones created on a system running Solaris 10 9/10.

System
Operating System
Number of Zones
Patches Applied
num_procs
Elapsed Time (hh:mm:ss)
X4100
Solaris 10 9/10
2
105
1
00:46:51
X4100
Solaris 10 9/10 2
105
2
00:36:04
X4100 Solaris 10 9/10 20
105 1
03:03:59
X4100 Solaris 10 9/10 20
105 2
01:55:58
X4100 Solaris 10 9/10 20
105 4
01:25:53


num_procs is used as a guide for the number of threads to be engaged in parallel patching.  Jeff Victor's blog (above) and the man page for pdo.conf talk about how this relates to the actual number of processes that are used for patching.

With only two zones, doubling the number of threads has an effect, but not a huge effect, since the amount of parallelism is limited.  However, with 20 zones on a system, boosting the number of zones patched in parallel can significantly reduce the time taken for patching.

Recall that all of this is done within the application of patches with Live Upgrade.  Used alone, outside of Live Upgrade, this can help reduce the time required to patch a system during a maintenance window.  Used with Live Upgrade, it reduces the time required to apply patches to the alternate boot environment.

So, what should you do to speed up patching and reduce the outage required for patching? 

Use ZFS root and Live Upgrade so that you can apply your patches to an alternate boot environment while the system is up and running.  Then, use parallel patching to reduce the time required to apply the patches to the alternate boot environment where you have zones deployed.

Monday Dec 20, 2010

Finish Scripts and First-Boot Services with Bootable AI

In my last couple of blogs, I have talked about using the Automated Installer, specifically using Bootable AI.  We talked about creating a manifest to guide the installation and we talked about creating a system configuration manifest to configure the system identity.  The piece that has not yet been addressed, from the perspective of a long-time Jumpstart user, is how to do the final customization via finish scripts.

In general, there is no notion of an install script that is bundled into a package when using the Image Package System in Solaris 11 Express as there is with SVR4 packages from Solaris 10.  However, a package can install a service that can carry out the same function.  Its operation is a bit more controlled since it has to have its dependencies satisfied and can run in a reduced privilege environment if needed.  Additionally, many of the actions typically scripted into installation scripts, such as creation of users, groups, links, directories, are all built-in actions of the packaging system.

So, the question arises of how to use the IPS packaging system to add our own packages to a system, whether at installation time or later, and how to perform the necessary first-boot customizations to a system we are installing.  The requirement to create our own packages comes from the fact that there is no other way to deliver content to the system being installed during the installation process except through the AI manifest - and that means IPS packages.  In Jumpstart, there was a variable set at installation that pointed to a particular NFS-mounted directory where install scripts could reside.  This was all well and good so long as you could mount that directory.  When it was not available, you were left again with the notion of creating and delivering SVR4 packages via the Jumpstart profile.  So, the situation is not far different than in Solaris 10 and earlier.  There's just a little different syntax and a different network protocol in use to deliver the payload.

Why Use a Local Repository

There are two main reasons to create a local repository for use by AI and IPS.  First, you might choose to replicate the Solaris repository rather than make a home-run through your corporate network firewall to Oracle for every package installation on every server.  Performance and control are clearly going to be better and more deterministic by locating the data closer to where you plan to use it.  The second reason to create a local repository would be to host your own locally provided packages - whether developed locally or provided by an ISV.

The question then arises whether to combine both of these into the same repository.  My personal opinion is that it is better to keep them separate.  Just as it is a good practice to keep the binaries and files of the OS separate from those locally created or provided by applications on the disk, it seems a good idea to keep the repositories separate.  That does not mean that multiple systems are needed to host the data, however.  Multiple repository services can be hosted on the same system on different network ports, pointing to different directories on the disk.  Think of it like hosting multiple web sites with different ports and different htdocs directories.

Rather than go through all the details of creating a local mirror of the Solaris repository, I will refer you to Brian Leonard's blog on that topic.  Here, he talks about creating a local mirror from the repository ISO.  He also shows how you can create a file-based repository for local use.

For much of the rest of this exercise, I am relying on an article in the OpenSolaris Migration Hub that talks about creating a First Boot Service, which in turn references a page on creating a local package repository.  It is well worth it to read through these two pages.

Setting Up A Local Repository

So far, we have avoided the use of any sort of install server.  However, to have a local repository available during installation, this becomes a necessity.  So, pick a server to be used as a package repository.

Rather than clone the Solaris repository, we will create a new, empty repository to fill with our own packages.  We will configure the necessary SMF properties to enable the repository.  And then we will fill it with the packages that we need to deploy.

On the host that will host the repository, select a location in its filesystem and set it aside for this function.  A good practice would be to create a ZFS filesystem for the repository.  In this case, you can enable compression on the repository and easily control its size through quotas and reservations.  In this example, we will just create a ZFS filesystem within the root pool.  Often you will have a separate pool for this sort of function.

# zfs create -p -o mountpoint=/var/repos/mycompany.com/repo -o compression=on rpool/repos/mycompany.com/repo

Next, we will need to set the SMF properties to support the repository.  The service application/pkg/server is responsible for managing the actual package depot process.  As such, it refers to properties to locate the repository on disk, establish what port to use, etc.

The property pkg/inst_root specifies where on the repository server's disk the repo resides.  

# svccfg -s application/pkg/server setprop pkg/inst_root=/rpool/repo0906/repo

pkg/readonly specifies whether or not the repository can be updated.  Typically, for a cloned Solaris repository, this will be set to true.  It also is a good practice to set it to true when it should not be updated.

# svccfg -s application/pkg/server setprop pkg/readonly=true

pkg/prefix specifies the name that the repository will take when specified as a publisher by a client system.  pkg/port specifies the port where the repository will answer.

# svccfg -s application/pkg/server setprop pkg/prefix=local-pkgs
# svccfg -s application/pkg/server setprop pkg/port=9000


Once the properties are set, refresh and enable the service.

# svcadm refresh application/pkg/server
# svcadm enable application/pkg/server


Creating a First-Boot Package

Now that the repository has been created, we need to create a package to go into that repository.  Since there are no post-install scripts with the Image Packaging System, we will create an SMF service that will be automatically enabled so that it will run when the system boots.  One technique used with Jumpstart was to install a script into /etc/rc3.d that would run late in the boot sequence and would then remove itself so that it would only run on the first boot.  We will take a similar path with our first-boot service.  We will have it disable itself so that it doesn't continue to run on each boot.  There are two parts to creating this simple package.  First, we have to create the manifest for the service, and second, we have to create the script that will be used as the start method within the service.  This area is covered in more depth in the OpenSolaris Migration Hub paper on Creating a First Boot Service.  In fact, we will use the manifest from that paper.

Creating the Manifest

We will use the manifest from Creating a First Boot Service directly and call it finish-script-manifest.xml.  The main points to see here are
  • the service is enabled automatically when we import the manifest
  • the service is dependent on svc:/milestone/multi-user so that it won't run until the system is in the Solaris 11 Express equivalent of run level 3.
  • the script /usr/bin/finish-script.sh, which we will provide, is going to be run as the start method when the service begins.

finish-script-manifest.xml:

<?xml version="1.0"?>
<!DOCTYPE service_bundle SYSTEM "/usr/share/lib/xml/dtd/service_bundle.dtd.1">

<service_bundle type='manifest' name='Finish:finish-script'>

<service
    name='system/finish-script'
    type='service'
    version='1'>

   <create_default_instance enabled='true' />

    <single_instance />

    <dependency name='autofs' grouping='require_all' restart_on='none' type='service'>
        <service_fmri value='svc:/system/filesystem/autofs:default' />
    </dependency>

<dependency name='multi-user' grouping='require_all' restart_on='none' type='service'>
      <service_fmri value='svc:/milestone/multi-user:default' />
   </dependency>


<exec_method
        type='method'
        name='start'
        exec='/usr/bin/finish-script.sh'
        timeout_seconds='0'>
    </exec_method>


   <exec_method
        type='method'
        name='stop'
        exec=':true'
        timeout_seconds='0'>
    </exec_method>

        <property_group name='startd' type='framework'>
                <propval name='duration' type='astring' value='transient' />
        </property_group>

</service>
</service_bundle>


Creating the Script

In this example, we will create a trivial finish script.  All it will do is log that it has run and then disable itself.  You could go so far as to have the finish script uninstall itself.  However, rather than do that we will just disable the service.  Certainly, you could have a much more expansive finish script, with multiple files and multiple functions.  Our script is short and simple:

finish-script.sh:

#!/usr/bin/bash
svcadm disable finish-script
#pkg uninstall pkg:/finish
echo "Completed Finish Script" > /var/tmp/finish_log.$$
exit 0


Adding Packages to Repository

Now that we have created the finish script and the manifest for the first-boot service, we have to insert these into the package repository that we created earlier.  Take a look at the pkgsend man page for a lot more details about how all of this works.  It's possible with pkgsend to add SVR4 package bundles into the repository, as well as tar-balls and directories full of files.  Since our package is simple, we will just insert each package.

When we open the package in the repository, we have to specify the version number.  Take a good look at the pkg(5) man page to understand the version numbering and the various actions that could be part of the package.  Since I have been working on this script, I have decided that it is version 0.3.  We start by opening the package for insertion.  Then, we add each file to the package in the repository, specifying file ownership, permissions, and path.  Once all the pieces have been added, we close the package and the FMRI for the package is returned.

# eval `pkgsend -s http://localhost:9000/ open finish@0.3`
# pkgsend -s http://localhost:9000/ add file finish-script-manifest.xml mode=0555 owner=root group=bin path=/var/svc/manifest/system/finish-script-manifest.xml restart_fmri=svc:/system/manifest-import:default
# pkgsend -s http://localhost:9000/ add file finish-script.sh mode=0555 owner=root group=bin path=/usr/bin/finish-script.sh
# pkgsend -s http://localhost:9000/ close
PUBLISHED
pkg://local-pkgs/finish@0.3,5.11:20101220T174741Z


Updating the AI Manifest

Now that the repository is created, we can add the new repository as a publisher to verify that it has the contents we expect.  On the package server, itself, we can add this publisher.  Remember that we set the prefix for the publisher to local-pkgs and that we specified it should run on port 9000.  This name could be anything that makes sense for your enterprise - perhaps the domain for the company or something that will identify it as local rather than part of Solaris is a good choice.

# pkg set-publisher -p http://localhost:9000 local-pkgs
pkg set-publisher:
  Added publisher(s): local-pkgs
# pkg list -n "pkg://local-pkgs/\*"
NAME (PUBLISHER)                                    VERSION         STATE      UFOXI
finish (local-pkgs)                                 0.3             known      -----


Now that we know the repository is on-line and contains the packages that we want to deploy, we have to update the AI manifest to reflect both the new publisher and the new packages to install.  First, to update the publisher, beneath the section that specifies the default publisher, add a second source for this new publisher:

      <source>
        <publisher name="solaris">
          <origin name="http://pkg.oracle.com/solaris/release/"/>
        </publisher>
      </source>
      <source>
         <publisher name="local-pkgs">
           <origin name="http://my-local-repository-server:9000/"/>
         </publisher>
      </source>


Then, add the packages to the list of packages to install.  Depending on how you named your package, you may not need to specify the repository for installation.  IPS will search the path of repositories to find each package.  However, it's not a bad idea to be specific.

      <software_data action="install" type="IPS">
        <name>pkg:/entire</name>
        <name>pkg:/server_install</name>
        <name>pkg://local-pkgs/finish</name>


Now, when you install the system using this manifest, in addition to the regular Solaris bits being installed, and the system configuration services executing, the finish script included in your package will be run on the first boot.  Since the script called by the service turns itself off, it will not continue to run on subsequent boots.  You can do whatever sort of additional configuration that you might need to do.  But, before you spend a long time converting all of your old Jumpstart scripts into a first-boot service, take a look at the built-in capabilities of AI and of Solaris 11 Express in general.  It may be that much of the work you had to code yourself before is no longer required.  For example, IP interface configuration is simple and persistent with ipadm.  Other new functions in Solaris 11 Express remove the need to write custom code, too.  But for the cases where you need custom code, this sort of first-boot service gives you a hook so that you can do what you need.

Booting and Installing with Bootable AI

My last couple of blogs have been about creating a manifest to be used when installing a system with the Solaris 11 Express Automated Installer.  Now that we have this basic manifest constructed, let's install a system.

To review, the Automated Installer is the facility in Solaris 11 Express that supports network-based installation.  The manifest used with AI determines what is installed and how the system is customized during installation.  

Typically, one would set up a network install service and fetch the manifest from there.  However, sometimes this is not desired or practical.  An option in these cases is to use bootable AI.  In this case, you boot the system to be installed from the AI ISO image.  During the boot process, you are prompted for a URL that points to a valid AI manifest.  This manifest is just fetched using HTTP (wget is actually used).  So, so long as you can get to the manifest, you are good to go.  Once fetched, the manifest is validated and acted upon to complete the installation.

In this installment, we will go through the boot process.  In particular, I will show what this looks like on an x86 host.  For details on SPARC, see my previous blog.

So, to start, boot your system from the Automated Install (AI) ISO.  When presented with the Grub menu, the default selection is to use a custom manifest.  This selection is the one we want and will prompt us for the URL of the manifest.  The other options allow you to use the default manifest built into the ISO and to perform the installation across a serial connection.



After the system has booted the small Solaris image on the AI ISO, you will be prompted for the URL of the manifest.



AI fetches the manifest and begins the installation process.  The installation goes on in the background rather than on the console.  Like the LiveCD installation, Solaris is running at this point.  If you want to monitor the progress of the installation, log in as the default admin user included in the ISO image.  The default login name is jack, with the password jack.  Once you have logged in, you can monitor the progress of the installation by tailing the installation log, found in /tmp/install_log.



Since Solaris is up and running, it is possible to enable network logins to the system while it is still installing.  To do this, su to root and enable the ssh service  (svcadm enable ssh).  Once ssh is enabled, you can ssh into the system as jack.  I have sometimes found this to be a useful tool when installing a virtual machine over a slow and unreliable network, where VNC is unable to sustain its required bandwidth.

Once the installation completes, you can reboot the system.  Of course, the regular first-boot SMF import will happen.  And the services that we configured in the last section will be activated to configure the networks and system identity. Once all of this complete, the system is ready for use.  The piece that you might have noticed is missing is any sort of finish-script customization.  Stay tuned for future installments to cover this.

Using the bootable AI, it is simple to provide a manifest via a simple URL and perform a near-hands-free, customized installation of the system.  It is important to note that DHCP is still used to fetch an address for the system, along with routing and DNS information.  For a truly hands-free installation, a network-based install server and install service would have to be created.

Using System Configuration Manifests with Bootable AI

In my last blog, I talked about how to configure a manifest for a bootable AI installation.  The main thing there was how to select which packages to install.  This time we are going to talk about how to handle AI's version of sysidcfg and configuring system identity at install-time.

In a Jumpstart world, many of the things that make up a system's identity - hostname, network configuration, timezone, naming services, etc. - can be configured at installation time by providing a sysidcfg file.  Alternately, an interactive dialog starts and prompts the installer for this sort of information.

The System Configuration manifest provides this same sort of information in an Automated Installer world.  The documentation for AI shows how to create either a separate or an embedded SC manifest to be served by an AI server.  When using Bootable AI, the SC manifest needs to be embedded within the AI manifest.  The SC manifest, whether embedded or not, is basically an XML document that is providing a bunch of properties for SMF services that are going to run on the first system boot to help complete the system configuration.  Some of the main tasks that can be completed in the SC manifest are:

  • Identify and configure the administrative "first user" created at install time.
  • Specify a root password and whether root is a role or a standard user
  • Configure timezone, hostname, keyboard maps, terminal type
  • Specify whether the network should be configured automatically or manually.
  • Configure network settings, including DNS, for manually configured networks

But, in the end, all of this is just setting SMF properties, so it's pretty straightforward.  It appears as a large service_bundle with properties for multiple SMF services.

As far as including the SC manifest information in the bootable AI manifest, the SC manifest is essentially embedded into the AI manifest as a large comment.  Don't be put off by the comment notation.  This whole section is passed on to SMF to assign the necessary service properties.

In order to explain the various sections of properties, I will just annotate an updated SC manifest.  In this manifest, I will specify some of the more common configuration settings you might use. 

The whole SC embedded manifest is identified within the AI manifest with the tag sc_embedded_manifest.  See the Automated Installer Guide for more details on the rest of the options to this tag.  The two lines following the sc_embedded_manifest tag are just the top part of the stand-alone SC manifest XML document.  Look in the default AI manifest for exact placement of this section.

    <sc_embedded_manifest name="AI">
      <!-- <?xml version='1.0'?>
      <!DOCTYPE service_bundle SYSTEM "/usr/share/lib/xml/dtd/service_bundle.dtd.1">    

The rest of the SC manifest sets up service properties for a service bundled named "system configuration."

      <service_bundle type="profile" name="system configuration">

The service system/install/config is responsible for doing some of the basic configuration actions at install-time, such as setting up the first, or admin, user, setting a root password, and giving the system a name.  The property group "user_account" specifies how the first user, used for administration, should be configured.  You can specify here the username (name="login"), an encrypted password, the GECOS field information (name="description"), as well as the UID and GID for the account.  Note that the default password supplied for the first user (by default, named jack) in the default manifest is "jack".

Special note should be made of the property "roles".  Recall that in Solaris 11 Express, root is no longer a regular login user, but becomes a role.  Therefore, in order to be able to assume the root role for administrative functions, this first user needs to be given the root role.  Other roles can also be specified here as needed.  Also notice that the profile "Primary Administrator" is no longer assigned to this first user, as was done in OpenSolaris.  Additional properties around roles, profiles, authorizations, etc. may be assigned.  See the Automated Installer Guide for details.

        <service name="system/install/config" version="1" type="service">
          <instance name="default" enabled="true">
            <property_group name="user_account" type="application">
              <propval name="login" type="astring" value="sewr"/>
              <propval name="password" type="astring" value="9Nd/cwBcNWFZg"/>
              <propval name="description" type="astring" value="default_user"/>
              <propval name="shell" type="astring" value="/usr/bin/bash"/>
              <propval name="uid" type='count' value='27589'/>
              <propval name="gid" type='count' value='10'/>
              <propval name="type" type="astring" value="normal"/>
              <propval name="roles" type="astring" value="root"/>
            </property_group>

As with Jumpstart, it is possible to specify a root password at install time.  The encrypted string for the root password is given here as the password property.  If no new password is supplied, the default root password at install-time is "solaris".  Also note here that root is created as a role rather than a regular login user.

            <property_group name="root_account" type="application">
                <propval name="password" type="astring" value="$5$dnRfcZs$Hx4aBQ161Uvn9ZxJFKMdRiy8tCf4gMT2s2rtkFba2y4"/>
                <propval name="type" type="astring" value="role"/>
            </property_group>

A few other housekeeping properties can also be set here for the system/install/config service.  These include the local timezone and the hostname (/etc/nodename) for the system.

            <property_group name="other_sc_params" type="application">
              <propval name="timezone" type="astring" value="US/Eastern"/>
              <propval name="hostname" type="astring" value="myfavoritehostname"/>
            </property_group>
          </instance>
        </service>

The system/console-login service establishes the login service for the console. Here you can specify the terminal type to be used for the console.

        <service name="system/console-login" version="1" type="service">
          <property_group name="ttymon" type="application">
            <propval name="terminal_type" type="astring" value="xterms"/>
          </property_group>
        </service>

The service system/keymap establishes what sort of keyboard input is to be expected on the system.

        <service name='system/keymap' version='1' type='service'>
          <instance name='default' enabled='true'>
            <property_group name='keymap' type='system'>
              <propval name='layout' type='astring' value='US-English'/>
            </property_group>
          </instance>
        </service>

By default, Solaris 11 Express enabled NWAM (NetWork Automagic) to automatically configure the primary network interface.  NWAM, by default, activates a primary network for the system, whether wired or wireless, monitors its availability and tries to restore network connectivity if it should go away.  Most people would say that its behavior is best suited for mobile or desktop systems, and it functions well in that space.  It includes the ability to have profiles that guide its behavior in a variety of networked environments.  NWAM relies on DHCP to get an available IP address and other data needed to configure the network.

In the default AI profile, the network/physical:nwam service instance is enabled and the network/physical:default service instance is disabled.  In most server configurations, static addressing and configuration might be more desirable.  In that case, you can do as we have below and switch with service instance is enabled and which is disabled by default.

        <service name="network/physical" version="1" type="service">
          <instance name="nwam" enabled="false"/>
          <instance name="default" enabled="true"/>
        </service>

In the case where we are doing static network configuration, we will rely on the network/install service to set up our networks.  The properties and values used here correspond to arguments to the ipadm command, new in Solaris 11 Express.  ipadm is used to configure and tune IP interfaces.  See its man page for details on syntax.

In this case, we are setting up a single IPv4 network interface (xnf0), giving it a static IP address and netmask, and specifying a default route.

        <service name="network/install" version="1" type="service">
          <instance name="default" enabled="true">
            <property_group name="install_ipv4_interface" type="application">
              <propval name="name" type="astring" value="xnf0/v4"/>
              <propval name="address_type" type="astring" value="static"/>
              <propval name="static_address" type="net_address_v4" value="192.168.100.101/24"/>
              <propval name="default_route" type="net_address_v4" value="192.168.100.1"/>
            </property_group>
          </instance>
        </service>

As with Jumpstart using sysidcfg, it is possible to set up DNS information at install-time.  Note that only DNS and not NIS or LDAP naming services can be set up this way.  The System Administration Guide: Naming and Directory Services manual discusses how to configure these naming services.  NIS+ is no longer supported in Solaris 11 Express.

The network/dns/install service is used to set up DNS at install-time.  For this, we specify the regular sorts of data that will populate the /etc/resolv.conf file: nameservers, domain, and a domain name search path.  Some of these data items take multiple values, so lists of values are used, as shown below.

        <service name="network/dns/install" version="1" type="service">
          <instance name="default" enabled="true">
            <property_group name="install_props" type="application">
              <property name="nameserver" type="net_address">
                <net_address_list>
                  <value_node value="1xx.xxx.xxx.zz"/>
                  <value_node value="1xx.xxx.xxx.yy"/>
                  <value_node value="1xx.xxx.xxx.xx"/>
                </net_address_list>
              </property>
              <propval name="domain" type="astring" value="us.warble.com"/>
              <property name="search" type="astring">
                <astring_list>
                  <value_node value="us.warble.com"/>
                  <value_node value="garble.com"/>
                  <value_node value="mfg.garble.com"/>
                </astring_list>
              </property>
            </property_group>
          </instance>
        </service>

And we close out the service bundle and the embedded SC manifest.

      </service_bundle>
      -->
    </sc_embedded_manifest>

So, by building a custom AI manifest with its embedded SC manifest, you can accomplish the same sorts of install-time configuration of a system as you could with Jumpstart and sysidcfg, without having to build any sort of complex finish scripts or any kind of extra coding.  This approach makes is possible to have a repeatable methodology for creating the administrative user, with known, standard credentials, and for configuring the base system networks and naming services.

Sunday Dec 19, 2010

Configuring Bootable AI in Solaris 11 Express

This is the first of several blogs around bootable AI, the ability with the Solaris 11 Express automated installer to boot directly from the AI ISO, fetch an installation manifest, and act on it, without having to set up an AI install server. Most of this focuses on the manifest, so it applies to AI booted from the network and from the ISO. However, I do not plan to go into creating and configuring the AI network services, at least not right now.  I think that other folks have talked about this already.

Solaris 11 Express includes the Automated Installer as the tool for performing automated network system installations. Using AI, it is possible to install a customized load of Solaris 11 Express, across the network, without manual intervention. AI allows you to specify which repositories to use, which packages to install from the repositories, and how to handle the initial system configuration (like sysidcfg) for the system.

Generally speaking, AI relies on a network automated install service to answer requests from a client trying to install it self. This is sort of like the jumpstart approach. The client starts to boot, looks around to see who on the network can help out, fetches what it needs from that network server, and goes ahead with the installation.

But, getting the base install information from the network isn't always feasible or even the most expeditious path. So, AI has a feature called "Bootable AI". I've blogged about this before, when it first came out in OpenSolaris.

The idea of bootable AI is that rather than rely on a network service to fetch the needed information to boot, you boot from the AI media instead. During the boot process, you can be prompted for a URL where an installation manifest can be found. The client fetches this manifest and carries on, just as it would from the AI service. The upside to this is that no AI service has to be installed on the network. The downside is that it does require at least one interaction if you want to specify a non-default manifest.

The manifest is the XML specification of how and what to install on the system. There is quite a lot that can be done in terms of selecting which disks to use, how to partition them, etc. Check the Oracle Solaris 11 Express Automated Installer Guide for detailed information on this.

In this note, I am going to show you how to put together some of the key parts of the manifest. My main goal is to then use this with bootable AI, but the same manifest can be installed with an install service in an AI server.

Locating a default manifest

How to get started? The simplest way to make a manifest is to start with the default manifest, delivered in the AI iso, and modify it to suit your needs. A default manifest is located in auto_install/default.xml in the AI ISO. Copy this and modify it as needed.

Selecting "Server Install" packages

When Solaris 11 Express is installed via the LiveCD or via the default manifest in AI, a full, desktop version of Solaris is installed. Often, however, when you use AI, you would prefer to have the smaller server installation provided by the text installer. Since the manifest specifies which top-level packages to install, this is easily accomplished.

In the default manifest, look for the software_data section with the install action. This section specifies what packages are to be installed. The two packages listed here are group packages, sort of like package clusters in Solaris 10. entire and babel_install are the packages that, when installed, provide the environment installed from the LiveCD. In order to get a reduced installation like that from the text installer, replace babel_install with server_install. If there are other packages that you want to add to the installation (for example the iSCSI packages referenced in the comments), you can add them here.

Change this section:

<software_data action="install" type="IPS">
        <name>pkg:/entire</name>
        <name>pkg:/babel_install</name>

to this section:

<software_data action="install" type="IPS">
        <name>pkg:/entire</name>
        <name>pkg:/server_install</name>

Uninstalling the appropriate packages

The server_install package bundle has dependencies of the packages that make up the reduced server installation. By installing it, we get all of the other packages that come with it. That's part of the coolness of IPS. However, we also want to preserve the ability to uninstall or modify individual components of that overall bundle. So, we finish out our installation by uninstalling the server_install wrapper. This does not affect the dependent packages; it just unwraps them so we can modify them directly. So, to do this, update the uninstall section as below.

Additionally, even with the reduced server installation, there may still be packages that we want to remove. For example, there are still over 700MB of system locales installed that you may not need and might choose to remove. You can add any other packages that you want to remove in this section as well. Note that this really does first install the package and then remove it. Seems sort of redundant, but I have not yet found a way to cause IPS to build a plan that would note the uninstalled packages and just mark them to be skipped during installation.

Change this:

</software_data>
      <!--
        babel_install and slim_install are group packages used to
        define the default installation.  They are removed here so
        that they do not inhibit removal of other packages on the
        installed system.
        -->
      <software_data action="uninstall" type="IPS">
        <name>pkg:/babel_install</name>
        <name>pkg:/slim_install</name>
</software_data> 

to this:

<software_data action="uninstall" type="IPS">
        <name>pkg:/server_install</name> 
        <name>pkg:/system/locale/af</name>
        <name>pkg:/system/locale/ar_eg</name>
        <name>pkg:/system/locale/as</name>
        <!-- ... -->
</software_data>

Any other packages that you want to uninstall can be listed here, too.

So, you see how easy it is to build a manifest for AI that specifies which packages you want to include or exclude and how to create a smaller, server installation for Solaris 11 Express.

Wednesday Mar 03, 2010

Installing OpenSolaris in Oracle VM for x86

Yeh, Virginia, you can install OpenSolaris as a guest in an Oracle VM for x86 environment!  Here is a little step-by-step guide on how to do it.  I am going to assume that you already have downloaded and installed Oracle VM Server.  Further, I am going to assume that you have already created an Oracle VM Manager system to manage your OVM farm.  All of that is more than I can tackle today.  But, to get you started, you can fetch the OVM am VM Manager bits from http://edelivery.oracle.com/linux .  I found the simplest thing to do was to create an Oracle Enterprise Linux management system and install the VM Manager there.

Once you have the OVM environment established, you need to get some installation media to install the guests.  For OpenSolaris, here's the magic: Bootable AI.  Check out Alok's blog for more details on exactly what the Bootable AI project is about.  But in a nutshell, this make it so that you can install OpenSolaris as if you were using a network install server, but while you are booted from installation media.  This gets around the difficulty of trying to do an installation using a LiveCD in a tiny VNC window and the difficulty of trying to get a network, PXE-based installation working.  This is a quick and easy way to go.

Fetch the OpenSolaris AI iso rather than the regular LiveCD iso.  Install this into the VM Manager resource repository. (Remember, I assum you know how to do this, or can figure it out pretty easily.  I did.)

Now, create a VM just as you always would for Oracle Enterprise Linux, Solaris, Windows, or whatever.  Select Install from installation media, and use the iso that you just added to the repostiory.  When you specify what operating system this VM will run, select "Other" since it isn't one of the pre-defined choices.  Start the creation and away you go.

As you have already figured out from Alok's blog, this is only half of the story.  You still must create an AI manifest.  The manifest details which packages to install and from where, along with the details for the first user created, root password, etc.  Check out the Automated Installation Project page for details on this.  The docs are pretty good and the minimum manifest needed for bootable AI is pretty basic.  Alok talks about how to specify booting from the development repository.  That was the only change to the default manifest that I made.

Put this manifest somewhere accessible via http from the VM you want to create.  The VM you created is sitting, waiting for you to tell it where to fetch its manifest so it can boot.  You really don't want to keep it waiting much longer.


Connect to the VM using VNC. You can use the built-in VNC client in VM Manager or whatever VNC client you like best. I tend to use vncviewer because it seems to manage the screen resolutions better than the Java client. When the installer prompts you for the manifest, enter the URL for the manifest you just made. The installer will fetch it, validate it, and then go on with its usual installation using that manifest. This is so simple and so cool!

Installation proceeds like it would with an install server.  You can log in on the console of the system being installed and monitor is progress.  Then, when it's done, reboot and you are done.

One note:  I have run into difficulting with OpenSolaris b133 and this approach.  When I used the b133 iso, even though I never got an error, the resulting VM was not bootable.  (No, I haven't got around to filing a bug on this.  Was going to wait until b134.)  However, if I use the b131 iso and a manifest that referenced installing entire@0.5.11-0.133 things worked out just fine.  So, give that a shot.

Once you have created a VM that you like within Oracle VM, you can do all of the cool Oracle VM things - convert it to a template and stamp out lots of copies, move it from server to server, etc.  But that's for another day.  Or that's something to look for in Honglin Su's blog.

Thursday Feb 18, 2010

ATLOSUG February Slides Posted

Slides from the February meeting of the Atlanta OpenSolaris User Group are posted at http://hub.opensolaris.org/bin/view/User+Group+atl-osug/ . The topic for this last meeting was "Oracle RAC on Solaris Logical Domains - Part 1". 

Don't miss part 2 of this presentation on March 9.

Tuesday Feb 16, 2010

It is indeed possible to install Oracle 11.2 on OpenSolaris

Found this cool post while checking my Google updates today.  Had not read this blog before, but I think I will give it a look. 

It is indeed possible to install Oracle 11.2 on OpenSolaris

Wednesday Feb 03, 2010

Oracle Virtual Machine Manager and OpenSolaris

This is pretty cool!  With a whole new set of products to become familiar with, I am jumping into Oracle VM Server and Oracle VM Manager.  So far, I've got 

  • Oracle VM Server installed on a pair of X8420 blades and have them set up as an HA pool
  • Oracle VM Manager installed on a v20z as my management interface
  • Oracle Enterprise Linux VMs - both PVM and HVM, installed from media and from pre-built templates
  • Nevada b130 as an HVM guest
  • Cloned VMs, migrated VMs on the fly between the blades
  • And now, I am installing OpenSolaris b131 using Bootable AI in a VM
Looks to me like the future is bright with lots of cool new tools that we can combine to get even more out of the technologies that both Sun and Oracle have created.

Monday Feb 01, 2010

Visit me at Wrenacres.com

Like so many other folks these last few days, I have migrated my personal blogging to my own site at Wrenacres.com.  The direct url for the blog is http://wrenacres.com/blog. Visit me there to see keep up with what I have been doing.  I also have my genealogical research posted at wrenacres.  

I will continue to update this blog with new and cool Solaris and OpenSolaris related topics.

I have already moved all former content from this site to Wrenacres.

Tuesday Jan 26, 2010

Unnatural Acts with AI

I'm pretty sure this is not what the AI team had in mind when they gave us bootable AI.  But in my quest to see what the oldest piece of gear I can run OpenSolaris, here's a fun one:

jack@opensolaris:~$ uname -a
SunOS opensolaris 5.11 snv_130 sun4u sparc SUNW,UltraAX-i2 Solaris
jack@opensolaris:~$ cat /etc/release
                      OpenSolaris Development snv_130 SPARC
           Copyright 2009 Sun Microsystems, Inc.  All Rights Reserved.
                        Use is subject to license terms.
                           Assembled 18 December 2009
jack@opensolaris:~$ 
telnet> send brk
Type  'go' to resume
ok banner
Sun Fire V100 (UltraSPARC-IIe 500MHz), No Keyboard
OpenBoot 4.0, 1024 MB memory installed, Serial #51701117.
Ethernet address 0:3:ba:14:e5:7d, Host ID: 8314e57d.
ok go
jack@opensolaris:~$ prtdiag
System Configuration:  Sun Microsystems  sun4u Sun Fire V100 (UltraSPARC-IIe 500MHz)
System clock frequency: 100 MHz
Memory size: 1024 Megabytes

Pretty much took forever to install, but it works like a champ.  More news as it occurs!

Thursday Jan 21, 2010

Random movie thoughts on a momentuous day

So, the EU has approved the acquisition of Sun by Oracle.  This coming Monday makes 15 years that I have been at Sun.  And this morning two movie scenes keep rolling around in my head.

First is from 1776, the great old musical about how the US came to be.  Right after the Continental Congress unanimously votes, after a long struggle, for independence from England, they all sit stunned that it has passed and John Adams, played by William Daniels just says, "It's done.  It's done."  They really didn't know what was in store, but they were confident of a bright future, albeit one that would require a huge effort on everyone's part.  (Just before this, he sang one of my favorite songs about commitment and pushing forward.)

The second is from Camelot.  I suspect a lot of us long-time Sun folks are feeling just a tad nostalgic right now for the place where "the rain would never fall till after sundown."  For many, Sun has been "for one brief shining moment" a really special place to be.  I've always thought of the people at Sun first when I think about this company.  Some of the finest, smartest, most willing to pitch in and help each other no matter what folks you will ever find.

Scott McNealy said it best in his keynote at Oracle OpenWorld this past October.  He said he wanted people to remember that Sun Kicked Butt, Had Fun, Didn't Cheat, Loved Our Customers, and Changed Computing Forever.   That about sums it up.

Now, the next chapter in Sun is about to start.  I think it's going to be bright with lots of opportunity and a great time all around.  But, no matter how wonderful it is, it will be different and we'll look back and miss many of the good times at Sun.

I'm excited about the next chapter.

Friday Jan 15, 2010

Bootable AI ISO is way cool

Alok Aggarwal posted, just before Christmas, a blog mentioning that the ISO images for the Auto Installer in OpenSolaris are now bootable.  Not just for x86 but also for SPARC.

This is huge!  While it does not provide a LiveCD desktop environment for SPARC, it does give us a way to easily install OpenSolaris on  SPARC gear.  Previously, it was necessary to set up an AI install server (running on an x86 platform since that was the only thing you could install natively) and use WAN Boot to install OpenSolaris on the SPARC boxes.  Well, that was a tough hurdle for some of us to get over.

Now, you can burn the AI ISO to a CD and boot it directly.  The default manifest on the disk will install a default system from the pkg.opensolaris.org  release repository.   Or, better yet, build a simple AI manifest that changes the release repository to the dev repo and put it somewhere you can fetch via http.  When you boot up, you will be prompted for the URL of the manifest.  AI will fetch it and use it to install the system.

{2} ok boot cdrom - install prompt
Resetting ...

Sun Fire 480R, No Keyboard
Copyright 1998-2003 Sun Microsystems, Inc.  All rights reserved.
OpenBoot 4.10.8, 16384 MB memory installed, Serial #57154911.
Ethernet address 0:3:ba:68:1d:5f, Host ID: 83681d5f.

Rebooting with command: boot cdrom - install prompt
Boot device: /pci@8,700000/ide@6/cdrom@0,0:f  File and args: - install prompt
SunOS Release 5.11 Version snv_130 64-bit
Copyright 1983-2009 Sun Microsystems, Inc.  All rights reserved.
Use is subject to license terms.
Hostname: opensolaris
Remounting root read/write
Probing for device nodes ...
Preparing automated install image for use
Done mounting automated install image
Configuring devices.
Enter the URL for the AI manifest [HTTP, default]: http://<my web server>/bootable.xml

See!  This is really easy and gives new life to really old gear.  In this case, the manifest is super simple, too.  I just grabbed the default manifest from an AI image and changed the repository and package to install.

$ pfexec lofiadm -a `pwd`/osol-dev-130-ai-x86.iso
/dev/lofi/1
$ pfexec mount -o ro -F hsfs /dev/lofi/1 /mnt
$ cp /mnt/auto_install/default.xml /etc/apache2/2.2/htdocs/bootable.xml

Edit this file and change

<main url="http://pkg.opensolaris.org/release" publisher="opensolaris.org"/>

to

<main url="http://pkg.opensolaris.org/dev" publisher="opensolaris.org"/>

Or as a speedup, add the mirror to pkg.opensolaris.org :

<main url="http://pkg.opensolaris.org/dev" publisher="opensolaris.org"/>
<mirror url="http://pkg-na-2.opensolaris.org/dev"/>

And change

<pkg name="entire"/>

to

<pkg name="entire@0.5.11-0.130"/>

You can add a mirror site for the repo in this manifest.  Or you can list other packages that you want to be installed as the system is installed.  The docs for the AutoInstaller talk about how to create and modify a manifest.

Some caveats that I found:  First, NWAM and DHCP might take longer than you think.  If you quickly try to type in the URL for the manifest, you may find that you have no network yet and become concerned.  I spent the better part of a day on this.  Then, I let it sit for a couple of minutes before trying the manifest URL and life was good.  My DHCP server is particularly slow on my network.

Second, not using the mirror, on a slow system took a really long time to install.  Have not diagnosed it to network download time or processing time.  I think some of both since things like the installation phase of babel_install took nearly an hour on one system.

Third, there must be a lower bound on what sort of system will work.  T2000 works just fine.  SF480R has worked fine.  My SF280R is busted - as soon as it's fixed, I'll try it.  Not so great on E220 and E420 systems.  They appear to work, but at the very end it says it failed.  The only failure message I can see this time is due to the installer finding a former non-global zone environment on the disk. But so far, my experience on UltraSPARC-II systems is that once the installation completes, it hangs on the first reboot or fails to boot at all.  I am not surprised that systems that are no longer supported are not supported by AI.  I think I saw in Alok's notes that OBP 4.17 was the minimum supported.  That means my USII boxes are right out, and  I think even the SF280.  I hate doing firmware updates, so I have not updated the SF480.

Fourth, when I tried to install on a system that previously had the root disk mirrored with SVM, zpool create for the root pool failed.  I had to delete the metadbs and the metadevices before I could proceed.

But, I am very impressed!  Bootable AI media is way cool.  Keep your eyes and ears open, though, for more developments in the AutoInstaller in the coming months.


Wednesday Jan 13, 2010

ATLOSUG January Slides Posted

Slides from the January meeting of ATLOSUG - the Atlanta OpenSolaris User Group - are posted at mediacast.sun.com.

Next meeting will be February 9, 2010.  Check our web site for details.

Time to move to OpenSolaris completely

The last build of SXCE, the Solaris Express Community Edition, Build 130 has been released.  So, what?

Well, this means that it's time for all of us laggards who have been basking in the glow of new features and capabilities given to us by the Solaris developers, but who have not been willing to take the plunge into OpenSolaris completely, need to get off the fence and move straight away to OpenSolaris.

I made that move over the holidays.  Got a new laptop.  Perfect time to make the move.  Used to be, I would run SXCE natively on my laptop and run OpenSolaris in a VirtualBox.  My rationale is that I do a lot of demonstrations for customers and I wanted my laptop to look as much like the production Solaris 10 as possible, while still getting the cool new stuff. 

Now, I run OpenSolaris native on the laptop and run Solaris 10 in a VirtualBox when I need it.

Turns out the migration has been remarkably painless.  My only hassle was actually moving my own data from one laptop to the other.

I guess that in the eggs and bacon breakfast of OSes, I have moved from being the chicken (involved in the process) to being the pig (fully committed).  And this is some tasty, thick sliced, smoked bacon!  Mmmm.

Monday Dec 14, 2009

Sillyt ZFS Dedup Experiment

Just for grins, I thought it would be fun to do some "extreme" deduping.  I started out created a pool from a pair of mirrored drives on a system running OpenSolaris build 129.  We'll call the pool p1.  Notice that everyone agrees on the size when we first create it.  zpool list, zfs list, and df -h all show 134G available, more or less.  Notice that when we created the pool, we turned deduplication on from the very start.

# zpool create -O dedup=on p1 mirror c0t2d0 c0t3d0
# zfs list p1
NAME   USED  AVAIL  REFER  MOUNTPOINT
p1      72K   134G    21K  /p1
# zpool list p1
NAME   SIZE  ALLOC   FREE    CAP  DEDUP  HEALTH  ALTROOT
p1     136G   126K   136G     0%  1.00x  ONLINE  -
# df -h /p1
Filesystem             size   used  avail capacity  Mounted on
p1                     134G    21K   134G     1%    /p1

So, what if we start copying a file over and over?  Well, we would expect that to dedup pretty well.  Let's get some data to play with.  We will create a set of 8 files, each one being made up of 128K of random data.  Then we will cat these together over and over and over and over and see what we get.

Why choose 128K for my file size?  Remember that we are trying to deduplicate as much as possible within this dataset.  As it turns out, the default recordsize for ZFS is 128K.  ZFS deduplication works at the ZFS block level.  By selecting a file size of 128K, each of the files I create fits exactly into a single ZFS block.  What if we picked a file size that was different from the ZFS block size? The blocks across the boundaries, where each file was cat-ed to another, would create some blocks that were not exactly the same as the other boundary blocks and would not deduplicate as well.

Here's an example.  Assume we have a file A whose contents are "aaaaaaaa", a file B containing "bbbbbbbb", and a file C containing "cccccccc".  If our blocksize is 6, while our files all have length 8, then each file spans more than 1 block.

# cat A B C > f1
# cat f1
aaaaaaaabbbbbbbbcccccccc
111111222222333333444444
# cat B A C > f2
# cat f2
bbbbbbbbaaaaaaaacccccccc
111111222222333333444444

The combined contents of the three files span across 4 blocks.  Notice that the only block in this example that is replicated is block 4 of f1 and block 4 of f2.  The other blocks all end up being different, even though the files were the same.  Think about how this would work as files numbers of files grew.

So, if we want to make an example where things are guaranteed to dedup as well as possible, our files need to always line up on block boundaries (remember we're not trying to be a real world - we're trying to get silly dedupratios).  So, let's create a set of files that all match the ZFS blocksize.  We'll just create files b1-b8 full of blocks of /dev/

# zfs get recordsize p1
NAME  PROPERTY    VALUE    SOURCE
p1    recordsize  128K     default
# dd if=/dev/random bs=1024 count=128 of=/p1/b1

# ls -ls b1 b2 b3 b4 b5 b6 b7 b8
 257 -rw-r--r--   1 root     root      131072 Dec 14 15:28 b1
 257 -rw-r--r--   1 root     root      131072 Dec 14 15:28 b2
 257 -rw-r--r--   1 root     root      131072 Dec 14 15:28 b3
 257 -rw-r--r--   1 root     root      131072 Dec 14 15:28 b4
 257 -rw-r--r--   1 root     root      131072 Dec 14 15:28 b5
 257 -rw-r--r--   1 root     root      131072 Dec 14 15:28 b6
 257 -rw-r--r--   1 root     root      131072 Dec 14 15:28 b7
 205 -rw-r--r--   1 root     root      131072 Dec 14 15:28 b8

Now, let's make some big files out of these.

# cat b1 b2 b3 b4 b5 b6 b7 b8 > f1
# cat f1 f1 f1 f1 f1 f1 f1 f1 > f2
# cat f2 f2 f2 f2 f2 f2 f2 f2 > f3
# cat f3 f3 f3 f3 f3 f3 f3 f3 > f4
# cat f4 f4 f4 f4 f4 f4 f4 f4 > f5
# cat f5 f5 f5 f5 f5 f5 f5 f5 > f6
# cat f6 f6 f6 f6 f6 f6 f6 f6 > f7

# ls -lh
total 614027307
-rw-r--r--   1 root     root        128K Dec 14 15:28 b1
-rw-r--r--   1 root     root        128K Dec 14 15:28 b2
-rw-r--r--   1 root     root        128K Dec 14 15:28 b3
-rw-r--r--   1 root     root        128K Dec 14 15:28 b4
-rw-r--r--   1 root     root        128K Dec 14 15:28 b5
-rw-r--r--   1 root     root        128K Dec 14 15:28 b6
-rw-r--r--   1 root     root        128K Dec 14 15:28 b7
-rw-r--r--   1 root     root        128K Dec 14 15:28 b8
-rw-r--r--   1 root     root        1.0M Dec 14 15:28 f1
-rw-r--r--   1 root     root        8.0M Dec 14 15:28 f2
-rw-r--r--   1 root     root         64M Dec 14 15:28 f3
-rw-r--r--   1 root     root        512M Dec 14 15:28 f4
-rw-r--r--   1 root     root        4.0G Dec 14 15:28 f5
-rw-r--r--   1 root     root         32G Dec 14 15:30 f6
-rw-r--r--   1 root     root        256G Dec 14 15:49 f7

This looks pretty weird.  Remember our pool is only 134GB big.  Already the file f7 is 256G and we are not using any sort of compression.  What does df tell us?

# df -h /p1
Filesystem             size   used  avail capacity  Mounted on
p1                     422G   293G   129G    70%    /p1

Somehow, df now believes that the pool is 422GB instead of 134GB.  Why is that?  Well, rather than reporting the amount of available space by subtracting used from size, df now calculates its size dynamically as the sum of the space used plus the space available.  We have lots of space available since we have many many many duplicate references to the same blocks.

# zfs list p1
NAME   USED  AVAIL  REFER  MOUNTPOINT
p1     293G   129G   293G  /p1
# zpool list p1
NAME   SIZE  ALLOC   FREE    CAP  DEDUP  HEALTH  ALTROOT
p1     136G   225M   136G     0%  299594.00x  ONLINE  -

zpool list tells us the actual size of the pool, along with the amount of space that it views as being allocated and the amount free.  So, the pool really has not changed size.  But the pool says that 225M are in use.  Metadata and pointer blocks, I presume.

Notice that the dedupratio is 299594!  That means that on average, there are almost 300,000 references to each actual block on the disk.

One last bit of interesting output comes from zdb.  Try zdb -DD on the pool.  This will give you a histogram of how many blocks are referenced how many times.  Not for the faint of heart, zdb will give you lots of ugly internal info on the pool and datasets. 

# zdb -DD p1
DDT-sha256-zap-duplicate: 8 entries, size 768 on disk, 1024 in core

DDT histogram (aggregated over all DDTs):

bucket              allocated                       referenced         
______   ______________________________   ______________________________
refcnt   blocks   LSIZE   PSIZE   DSIZE   blocks   LSIZE   PSIZE   DSIZE
------   ------   -----   -----   -----   ------   -----   -----   -----
  256K        8      1M      1M      1M    2.29M    293G    293G    293G
 Total        8      1M      1M      1M    2.29M    293G    293G    293G

dedup = 299594.00, compress = 1.00, copies = 1.00, dedup \* compress / copies = 299594.00

So, what's my point?  I guess the point is that dedup really does work.  For data that has a commonality, it can save space.  For data that has a lot of commonality, it can save a lot of space.  With that come some surprises in terms of how some commands have had to adjust to changing sizes (or perceived sizes) of the storage they are reporting.

My suggestion?  Take a look at zfs dedup.  Think about where it might be helpful.  And then give it a try!

Friday Dec 11, 2009

ATLOSUG December Meeting slides posted

We had a great meeting of ATLOSUG, the Atlanta OpenSolaris User Group, this past Tuesday.  20+ people attended our first meeting with our new host, GCA Technology Services, at their training facility in Atlanta.  A big "Thank You" to Dawn and GCA for hosting our group.

Our topic this time was "What's New In ZFS" and we talked about some of the new features that have gone into ZFS recently, especially DeDupe.  George Wilson of the ZFS team was kind enough to share some slides that he had been working on and they are posted here.

Our next meeting will be Tuesday, January 12 at GCA.  Details and info can be found on the ATLOSUG website at http://hub.opensolaris.org/bin/view/User+Group+atl-osug/

Sunday Oct 18, 2009

Gizmodo reviews Virtual Box

Nice review at Gizmodo, here, of VirtualBox.  Title is Virtualize Any OS for Free.  Check it out.

Monday Aug 17, 2009

ATLOSUG COMSTAR slides posted

Slides from last week's meeting of the Atlanta OpenSolaris User Group (ATLOSUG) are posted now on the group website - http://opensolaris.org/os/project/atl-osug

We had a good group of about 16 people in attendance and a great discussion around how and why to use COMSTAR. 

The next meeting will be held on Sept. 8.  The topic will be how COMSTAR and other OpenSolaris technologies fit together in the Sun Unified Storage family of products.  Hope to see you there!

Monday Jun 29, 2009

Quick Review of Pro OpenSolaris

Pro OpenSolaris - Harry Foxwell and Christine Tran

Several (too many) weeks ago, I said that I was going to read and review Harry & Christine's new book, Pro OpenSolaris. Finally, I am getting around to doing this.

Overall, I was pleased with Pro OpenSolaris.  It does a good job at what it tries to do.  The key is to recognize when it is the right text and when others might be the right text.  Right in the Introduction, the authors are clear that this is an orientation tour.  They say "We assume that you are a professional system administrator ... and that your learning style needs only an orientation and in indication of what should be learned first in order to take advantage of OpenSolaris."  That's a good summary of the main direction of the book.  And at this, it does a very nice job!

This means that Pro OpenSolaris is not an exhaustive reference manual on all of the features and nuances of OpenSolaris.  Instead, it's a broad overview of what OpenSolaris is, how it got to be what it is, what is key features and differentiators are, and why I might choose to use OpenSolaris instead of some other system.  That's important to realize from the outset.  If you are looking for the thousand-page reference guide, this is not the one.  If you have heard about OpenSolaris and want to explore a bit more deeply, to decide whether or not OpenSolaris is something that might help your business or might be a tool you can use, this is a great place to start.
Pro OpenSolaris spends a good bit of time on the preliminaries.  There is an extensive section on the philosophical differences between the approaches and requirements of different open source licenses and styles of licenses.  Pro OpenSolaris explains clearly why OpenSolaris uses the CDDL license as opposed to other licenses and how this fits in with the overall goal of the OpenSolaris project.

Pro OpenSolaris helps you get started, with a lengthy discussion of how to go about installing OpenSolaris either on  bare metal or in a virtual machine.

Compare this to the OpenSolaris Bible (Solter, Jelinek, & Miner), which really does aspire to be the thousand-page reference guide.  In the OpenSolaris Bible, licensing and installation are given only a short discussion, since they are not central to the book's focus.  Instead, the reader is directed to other places for that discussion.

But that's why it's important to have both books.  Pro OpenSolaris gives the tour of the important parts of the OpenSolaris operating system, how and why I might use them, and why they are important, but it does not go deeply into the details.  That's probably wise for an operating system that is still growing and changing substantially with each new release.

One thing that particularly interested me in Pro OpenSolaris was the fact that it includes large sections on both the OpenSolaris Webstack which includes IPS-packaged versions of the commonly used pieces of an AMP stack - notably, Apache, MySQL, PHP, lighttpd, nginx, Ruby, Rails, etc - all compiled and optimized for OpenSolaris and including key add-ons such as DTrace providers where applicable.  Pro OpenSolaris also has a nice, long chapter on NetBeans and its role as a part of an overall OpenSolaris development environment.

What's my take overall?  Pro OpenSolaris is a quick read that will give you a good understanding of what OpenSolaris is and why you would want to use it; what it's key features are and why they are important; and how you can use these to your best advantage.  There are lots of examples and technical details so that you can see that what Harry & Christine talk about is for real.  I would recommend this as part of your library.  But I would also recommend the OpenSolaris Bible.  The two complement each other nicely to complete the picture.

Saturday Jun 13, 2009

June Atlanta OpenSolaris User Group meeting

Had a great Atlanta OpenSolaris User Group meeting this month.  We did an installfest, an update from CommunityOne, and a recap of what's new in OpenSolaris 2009.06.  About twenty folks showed up and about half loaded their laptops with the new build while we were there.

We got some great feedback for upcoming topics and are pushing forward with that.  We also decided to move back to monthly meetings starting in August.  Our next meeting is August 11 when we will talk about COMSTAR.  We are also considering a change in venue back to the Sun office in Alpharetta.  Matrix Resources has been very gracious in allowing us to use their facility, but I always feel bad that they have to have someone stick around until late at night to babysit us.

We're going to try an experiment to see if we can't get the word out a little better about our merry band via social networks.  We've started by creating a Meetup group at http://meetup.com/atlosug.  Hopefully this might generate more traffic to our meetings and help us find folks in the area.

Tuesday Jun 09, 2009

OpenSolaris User Group Leaders Bootcamp

The keepers of the OpenSolaris Community took advantage of having a number of the User Group leaders at the CommunityOne conference this last week to set aside a day for a User Group Leaders' Bootcamp.

What a great opportunity to get together in the same room with folks working to create and sustain OpenSolaris user groups around the world! We had folks from every continent - from Atlanta and Argentina, from Dallas and Serbia, from China and London, and on and on. Something like twenty-five to thirty of the OpenSolaris User Groups were represented.

The whole day was a great experience. It was great to see that as different as each group was, there were a lot of common themes for both successes and for challenges. And a lot of great ideas were shared as to how to boost participation, to improve meetings, and to improve the success of the groups overall. It will be exciting to hear a report back next year on how these ideas have played out.

Be sure to check out Jim Grisanzio's photos to see some of these characters and what all went on at CommunityOne and in the OSUG Bootcamp.

Jeff Jackson, Sr. VP for Solaris Engineering, started the day off with a greeting and charge to get the most out of this opportunity to meet with each other and with the OpenSolaris and Solaris headquarters teams.

Since the thing that brought this group together was a common focus on OpenSolaris User Groups and not the fact that we knew each other, we began the day with a bit of team-building exercise, courtesy of The Go Game. This is a cross between a scavenger hunt and an improvisational acting class. Teams criss-crossed downtown San Francisco trying to find and photograph places hinted at by clues on web pages. At some venues, the teams had to act out and film various tasks. For example, on the Yerba Buena lawn, the team had to engage in an impromptu Tai Chi exercise in order to find their long-lost phys ed teacher, Ms. Karpanski, who then led the team in creating a new exercise video. Once we all returned, all of our submissions were voted on by the team and a winning team chosen. Supposedly, we can see all these photos and videos. Haven't yet found out how. Perhaps, that's for the best!

In order for us to get to know each other's groups, each User Group prepared a poster describing the group, where we were located, what we do, what sort of members make up the group, and what makes us special. Many of these posters were really well done! We had a bit of a scavenger hunt for answers to questions found by careful reading of all of the posters. It was really cool to see what sorts of projects some of the groups had undertaken and how they were working with various university or other organizations.

But the main part of the day was spent in a big brainstorming session. We all identified our successes, our failures, our challenges, and ideas for the future. We put all of these on several hundred post-it notes and placed them on large posters. We grouped them by topic and then went through all of these. Even though this only had an hour on the agenda, it ended up taking the bulk of the day. Since this was the most important thing for us, we decided to rearrange the day to accommodate it.

From these sticky-notes, we found out that some of our groups were mostly focused on administrators but others had a large developer population. We all have some sort of issues around meeting locations - whether it's a matter of access in the evening, finding a convenient location, or providing network access and power. For most groups, having some sort of refreshments was important, though some groups felt like good refreshments attracted too many folks who just show up for the food.

There were a lot of good ideas around using a registration site to get access to the facility and order food, creating and using Facebook, LinkedIn, and Twitter, using IRC, interacting with the Sun Campus Ambassadors, using MeetUp to find new members. Many folks found it useful to video and make available presentations given at their meetings. Some groups (for example in Japan) have special sub-groups for beginners. Other groups are doing large-scale development projects, such as the Belenix project in Bangalore.

For me and the Atlanta OpenSolaris User Group, I have a lot of new ideas that I want to put out to our membership and our leaders - move back to monthly meetings, use a registration site, set up a presence on various social networks.

Many people said that folks come to the user groups in order to network and expand their circle of business acquaintances. In light of the current economic situation, with so many smart people out of work, I am thinking of promoting our group with some of the job networking groups around Atlanta. For example, my church, Roswell United Methodist Church, has one of the largest job networking groups in the Atlanta area. Every two weeks, nearly 500 people meet to network and help each other in their job search. Perhaps the many IT folks in this group might find this a way to get current and stay current in a whole new area.

At any rate, I am inspired to get things cranking at ATLOSUG!

After spending the afternoon working through our hundreds of sticky notes, the OpenSolaris Governing Board had a bit of a roundtable with us to talk about what they do and how we can work better together. It was really helpful for me to hear from them and to get to put faces to some of the names for the folks I did not already know.

We finished out the evening with a great dinner at the Crab House at Pier 39. From what I have seen, many of the photos from dinner and the meeting are already on Facebook, Flickr, and likely blogs.sun.com. Jim Grisanzio, OpenSolaris Chief Photographer, was out in force with his camera!

Thanks so much to Teresa Giacomini, Lynn Rohrer, Dierdre Straughan, Jim Grisanzio, Tina Hartshorn, Wendy Ames, Kris Hake and everyone else who had a hand in organizing this event. Thanks to Jeff Jackson, Bill Franklin, Chris Armes, Dan Roberts and all the other HQ folks who took the time to come and listen and interact with the leaders of these groups. I know that I got a lot out of the meeting and am more eager than ever to promote and push forward with our user group.

CommunityOne Recap

Last week, I had the opportunity to attend CommunityOne West in San Francisco, along with a number of the other leaders of OpenSolaris User Groups. (I head up the Atlanta OpenSolaris User Group.) What a great meeting! Three days of OpenSolaris.

First off, I am sure that Teresa and the OpenSolaris team selected the Hotel Mosser because they knew it was a Solaris focused venue. As Dave Barry would say, I am not making this up! Even the toilet paper was Solaris-based. Bob Netherton and I were speculating that perhaps this was an example of Solaris Roll-Based Dump Management, new in OpenSolaris 2009.06.

CommunityOne Day One

Day One was a full day of OpenSolaris and related talks. The OpenSolaris teams maintained tracks around deploying OpenSolaris 2009.06 in the datacenter and around developing applications on OpenSolaris 2009.06. For the most part, I stuck with the operations-focused sessions, though I did step out into a few others. Some of the highlights included:

  • Peter Dennis and Brian Leonard's fun survey of what's new and exciting in OpenSolaris 2009.06. ATLOSUG folks should look for a reprise of this at our meeting on Tuesday.
  • Jerry Jelinek's discussion of the various virtualization techniques built into and onto OpenSolaris. This is a sort of talk that I give a lot. It was really helpful to hear how the folks in engineering approach this topic.
  • Scott Tracy & Dan Maslowski's COMSTAR discussion and demo. COMSTAR has been significantly expanded in recent builds, with more coolness still to come. I had not paid a lot of attention to this lately and this was a really helpful talk, especially since Teresa Giacomini had asked me to present this demo for the user group leaders on Wednesday. In any case, I have reproduced the iSCSI demo that Scott did using just VirtualBox, rather than requiring a server. Of course, the VB version is not something I would run my main storage server on. But it certainly is a great tool to understand the technology. I hope to have Ryan Matteson (Ryan, you volunteered!) give a talk at the ATLOSUG sometime soon.
  • I branched out of main OpenSolaris path to see a few other things on Day One, as well. Ken Pepple, Scott Mattoon, and John Stanford gave a good talk on Practical Cloud Patterns. They talked about some of the typical ways that people do provisioning, application deployment, and monitoring within the cloud.
  • Karsten Wade, "Community Gardener" at Red Hat, gave a talk called Participate or Die. This was about the importance of participating in the Open Source projects that are important to your business. He talked about understanding the difference in participating (perhaps, using open source code) and influencing (helping to guide the project). By paying more attention to those who actively participate, active members of the community enhance their status and become influencers of the direction for a project. And it is important that this happen - in successful projects, the roadmap is driven by the participants rather than handed down on high with the hope that people will line up behind it. Really, I think, his key message was that it is important not to just passively stand by when you care about or depend upon something, leaving its future in the hands of others.
  • Kevin Nilson and Michael Van Riper gave a great talk about building and maintaining a successful user group. This was built on their experiences with the Silicon Valley Java User Group and with the Google Technology User Group. They took a great approach by collecting videos from the leaders, hosts, and participants in these and other groups around the country. It was really helpful to hear people's perspectives on why they attend a group, why companies host group meetings, and why and how people continue to lead user groups. While a lot of what they had to say, and the successes that they have had, are a product of being in a very "target-rich environment" in Silicon Valley, it was interesting to see that some things are universal: a good location makes a lot of difference; having food matters. I got a lot of ideas from this and from the OpenSolaris User Group Bootcamp that I hope to get going in ATLOSUG.
  • OpenSolaris 2009.06 Launch Party finished out the evening. Dodgeball and the Extra Action Marching Band. I thought these folks were the hit of the evening. You get the best of marching bands, big drums, loud brass, but add to that folks flaying around, throwing themselves at the dodgeball court nets. Much more exciting than your regular marching band, even some of the cool ones around Atlanta in the Battle of the Bands!

CommunityOne Day Two

Day Two was filled with OpenSolaris Deep Dives. These were very helpful, not just in content, but in helping me to hone my own OpenSolaris presentations. For this day, I stuck close to the Deploying OpenSolaris track, having learned in graduate school that I am not a developer. This track included:

  • Chris Armes kicked off the day with a talk on deploying OpenSolaris in your Data Centre (as he spells it).
  • Becoming a ZFS Ninja, presented by Ben Rockwood. Ben is an early adopter and a production user of ZFS. This was a two-hour, fairly in-depth talk about ZFS and its capabilities.
  • Nick Solter, co-author of the OpenSolaris Bible, talked about OpenHA Cluster, newly released and available for OpenSolaris. With OpenHA, enterprise-level availability is not just available, but also supported. He talked about how the cluster works and about extensions to the OpenHA cluster beyond the capabilities of Solaris Cluster, based on OpenSolaris technologies. Some of these include the use of Crossbow VNICs for private interconnects. I am still thinking about the availability implications of this and am not sure it's an answer for all configurations. But it's cool that it's there!
  • Jerry Jelinek rounded out the day talking about Resource Management with Containers, a topic near and dear to my heart and one I end up presenting a lot.
We finished out Day Two with a reunion dinner of some of the old team at Bucca di Beppo. Around the table, we had Vasu Karunanithi, Dawit Bereket, Matt Ingenthron, Scott Dickson (me), Bob Netherton, Isaac Rosenfeld, and Kimberly Chang. It was great to get at least part of the old gang together and catch up.

Day Three was the OpenSolaris User Group Leaders Bootcamp. But that's for another post....

Monday May 25, 2009

EBC Goes On the Road

Sun's Executive Briefing Center is on the road this week.  We are visiting with customers in Cleveland, Columbus, and Detroit.  Looks like a busy schedule and I am looking forward to the trip.  I was asked to fill in at the Solaris Virtualization speaker for this trip.

We fly to Cleveland and fly home from Detroit.  Kate has arranged a bus to get us from Cleveland to Columbus to Detroit.  My wife calls it Geeks on a Bus and thought it sounded too scary to contemplate!

We'll be talking about Sun's Vision, Systems, Software, OpenStorage, Solaris, Virtualization of Systems, Desktop Virtualization, and Services to support all of these.  Hope to see many of you there.

Saturday May 09, 2009

Reminder of Jumpstart Survey

Last week, I blogged about a Jumpstart Survey.  I've gotten good comments and some responses to the survey.  It's been a week, but I want to collect some more responses before posting an analysis.  Take a look at my previous blog and fill out the survey or comment on the blog.  I will summarize and report in another week or so.

About

Interesting bits about Solaris, Virtualization, and Ops Center

Search

Archives
« April 2014
SunMonTueWedThuFriSat
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
   
       
Today