Explore NY Stream

— LiveStream

A NIM install on AIX turns one server into a network boot and deployment master that can rebuild any LPAR over Ethernet, while CSM coordinates the hardware and VIOS virtualizes the storage and network. This guide walks the full build end to end — preparing the NIM master, defining lpp_source, SPOT and mksysb resources, wiring CSM to the HMC, and netbooting clients — with the legacy commands corrected and the modern equivalents flagged so the workflow still makes sense on a supported AIX level.

What NIM, CSM and VIOS actually do

NIM (Network Installation Management) is AIX's built-in framework for installing and maintaining operating systems across the network. One machine becomes the NIM master; every machine it serves is a NIM client. The master holds installable resources — software sources, boot images and system backups — and pushes them to clients over the LAN using BOOTP and TFTP, so you never touch a physical CD per box.

CSM (Cluster Systems Management) was IBM's tool for managing a fleet of AIX/Linux nodes: remote power, remote console, and remote command execution through the HMC. CSM is end of life — IBM withdrew it and the supported successor is xCAT (Extreme Cloud Administration Toolkit), which performs the same node-definition, hardware-control and NIM-orchestration role on current Power hardware. The concepts below map almost one to one onto xCAT.

VIOS (Virtual I/O Server) is a special partition that owns physical adapters and shares disk and network to client LPARs through virtual SCSI and a Shared Ethernet Adapter (SEA). VIOS is very much current technology and the steps here remain valid on modern releases.

Important currency note: the original procedure targets AIX 5.3, which is long out of support, along with CSM 1.4 and RSCT 2.4. Treat the exact fileset and RPM versions as historical. On a supported stack you would use a current AIX TL/SP, xCAT instead of CSM, and a recent VIOS — but the NIM master, resource and netboot mechanics are unchanged.

Prerequisites and base OS for the NIM install on AIX

Before any NIM install on AIX, the future master needs a clean base OS, name resolution, a multipath driver for its SAN disks, and a dedicated filesystem for the install repository.

Base OS: a minimal AIX install on the master, plus the matching multipath driver (the original used sddpcm; on current AIX use the native AIX PCM / MPIO).
Name resolution: populate /etc/hosts with the master, the HMC, and every client and VIOS — NIM and CSM both resolve by name.
Networking: the master and all clients must share an install VLAN reachable by BOOTP/TFTP (no router in the boot path unless you configure a BOOTP relay).
Disk: spare disks for a dedicated install volume group so the repository never competes with rootvg.

Add the CSM tools to your shell environment in /etc/profile so the binaries and man pages are on the path:

export PATH=$PATH:/opt/csm/bin
export MANPATH=$MANPATH:/opt/csm/man
set -o vi and stty erase ^H for a sane editing experience on a serial console.

Create the install volume group and filesystem

CSM and NIM share one large repository, historically mounted at /csminstall (under xCAT this is /install). Create a dedicated volume group, a JFS2 log, a large JFS2 logical volume, and the filesystem. With a 64 MB physical-partition size, 80 PPs gives roughly 5 GB — size yours far larger today, since a single AIX lpp_source alone can exceed that.

Create the VG across two disks: mkvg -f -y csmvg -s 64 -B hdisk2 hdisk4
Create the data LV: mklv -y csminstallLV -t jfs2 -x 9999 -e x csmvg 80
Create the JFS2 log LV: mklv -t jfs2log -y csmjfs2log csmvg 1
Format the log: echo y | logform /dev/csmjfs2log
Create and mount the filesystem: crfs -v jfs2 -d /dev/csminstallLV -m /csminstall -A yes -p rw -a logname=csmjfs2log then mount /csminstall

The original line carried a stray -t no flag, which is not valid for crfs -v jfs2 — that has been removed above. Confirm the mount with df -g /csminstall.

Install the prerequisite filesets and updates

CSM and its open-source helpers depend on a handful of AIX filesets. Stage and install them in order:

Performance agent: verify perfagent.tools is installed (RSCT depends on it).
Java: the GUI components need a Java runtime/SDK (the original used Java 1.4; today use a current 64-bit Java).
X11 compatibility: install X11.compat.lib.X11R5 for the legacy Tk 8.3; selecting it pulls in X11.base.lib, X11.base.common and X11.base.smt. Run updtvpkg afterward so the RPM database knows the AIX-installed X11 libraries exist.

Then apply the AIX maintenance level (the original applied 5.3 ML2). The clean modern equivalent is a Technology Level plus Service Pack. The general update flow is:

Refresh the package table of contents in the fix directory: inutoc .
Update the install tooling first: installp -acgXd . bos.rte.install
Apply the rest with smitty update_all (or install_all_updates -d . on current AIX, which sequences prerequisites for you).

Install RSCT, CSM and the open-source helpers

Install RSCT (the reliable clustering layer CSM rides on) and the CSM filesets, then their fixes. CSM also relies on several open-source packages delivered as RPMs and AIX-packaged RPMs: expect, tcl, tk, conserver (the console concentrator) and the CIM provider openCIMOM.

Install the RPM-style packages with geninstall, which understands both AIX installp images and RPMs in one pass:

geninstall -IaX -d . R:expect R:tcl R:tk R:conserver
To include the CIM provider as well: geninstall -IaX -d . R:expect R:tcl R:tk R:conserver R:openCIMOM

The R: prefix tells geninstall the named item is an RPM. You may see a warning that the CIM browser wants a specific xerces.jar — it is non-fatal; add the jar to CLASSPATH only if you actually use the browser. Bump the per-user process limit so the daemons and parallel commands do not hit it: chdev -l sys0 -a maxuproc=4096.

Secure remote access with OpenSSL and OpenSSH

CSM drives nodes over SSH, so install OpenSSL (the AIX RPM) first, then OpenSSH (the AIX installp packages):

Install OpenSSL from its RPM, e.g. rpm -i openssl-x.x.x.aix*.ppc.rpm (and the matching -doc RPM if you want the docs).
Install OpenSSH with smitty install_latest against the openssh.* filesets, or installp -acXgd . openssh.

Always pair OpenSSH with an OpenSSL build new enough to satisfy its dependency; mismatched pairs are the most common failure here. Verify the daemon with lssrc -s sshd and a local ssh localhost.

Configure the CSM management server

Install the CSM server filesets (csm.server, plus csm.gui.dcem and csm.gui.websm if you want the GUIs), start RSCT with startsrc -g rsct, then point CSM at SSH and accept the license:

Set the remote transport to SSH/SCP and enable remote-shell setup for clients:
csmconfig RemoteCopyCmd=/usr/bin/scp RemoteShell=/usr/bin/ssh SetupRemoteShell=1
Make sure the path you point at really exists. The original referenced /usr/local/bin/ssh and symlinked scp into /usr/bin; AIX OpenSSH actually installs to /usr/bin, so use those real paths and skip the symlink. Confirm with ls -l /usr/bin/ssh /usr/bin/scp.
Accept the CSM license: csmconfig -L
Copy the CSM client payload into the repository: csmconfig -c
Set a cluster ID and store the HMC credentials so CSM can drive power/console:
csmconfig -s <ClusterID> and systemid <hmc-hostname> hscroot

Validate the management server with probemgr -p ibm.csm.ms -l 0, which runs the built-in health probes and reports any broken dependency before you try to install a node.

Initialize the NIM master and core resources

This is the heart of the NIM install on AIX. Configure the master with smitty nim (which runs nimconfig against the install interface), then define the three resources every install needs: an lpp_source (the software), a SPOT (the network boot/runtime image), and an mksysb (a cloneable system backup).

Define an lpp_source from the AIX media or a directory of filesets:
nim -o define -t lpp_source -a source=/dev/cd0 -a server=master -a location=/csminstall/AIX/aix530/lppsource aix530_lppsource
Build a SPOT from that lpp_source (this generates the network boot images under /tftpboot):
nim -o define -t spot -a source=aix530_lppsource -a server=master -a location=/csminstall/AIX/aix530/spot aix530_spot
Stage extra software into the lpp_source so clients get it at install time: copy the OpenSSL RPMs into the RPMS/ppc tree, and use smitty bffcreate to place OpenSSH into the installp/ppc tree, then run inutoc and nim -o check on the lpp_source.

To keep the SPOT current, build a second lpp_source for the maintenance level and update the SPOT against it with smitty nim_res_op (the update_all operation). Hard-link rather than recopy shared filesets to save space.

Define bosinst_data, bundles and the mksysb

For a hands-off overwrite install, create a bosinst_data resource that answers every BOS install prompt, and installp_bundle resources that list the extra software to add during the install.

bosinst_data — the key non-prompting settings:

Field	Value
CONSOLE	/dev/vty0
INSTALL_METHOD	overwrite
PROMPT	no
EXISTING_SYSTEM_OVERWRITE	yes
ACCEPT_LICENSES	yes
ENABLE_64BIT_KERNEL	yes
CREATE_JFS2_FS	yes
BOSINST_LANG / CULTURAL_CONVENTION / MESSAGES / KEYBOARD	en_US

Define it with nim -o define -t bosinst_data -a server=master -a location=/csminstall/AIX/nim/bosinst.aix530 aix530_bid.

installp_bundle — a small text file naming filesets/RPMs, e.g. an openssh.bnd containing I:openssh.base, I:openssh.license, I:openssh.man.en_US, I:openssh.msg.en_US (or simply I:openssh for a newer single-fileset package), and an openssl.bnd with R:openssl*. The I: prefix is an installp fileset, R: an RPM.
mksysb — a system image of a reference machine, defined with type mksysb and pointed at the backup file under /csminstall/images. This is what lets you clone an identical, fully patched build to many LPARs.

Define nodes, get adapters and prepare for netboot

Now register each client with both CSM and NIM. CSM defines the node and its HMC power method; getadapters learns the install NIC's MAC; then CSM generates the matching NIM client objects.

Define the node and add it to a group:
definenode -n <node> -H <hmc> PowerMethod=hmc then nodegrp -a <node> <group>
Collect adapter/MAC data: getadapters -n <node> -z /tmp/adapters, then set the install adapter attributes with chnode (type, speed, duplex, netmask and the discovered MAC address).
Generate NIM clients and groups from the CSM definitions:
csm2nimnodes -n <node> and csm2nimgrps -N <group>; verify with lsnim -l <node>.
Let CSM seed the NIM customization (scripts, SSH keys) for the node: csmsetupnim -n <node>.

The source had a typo defining client sc5h05101 against group operations for sc5h0501 — keep node names consistent everywhere, because NIM, CSM and /etc/hosts must all agree exactly.

Allocate resources and netboot the client

Allocate the resources to the target with smitty nim_mac_res (lpp_source, SPOT, mksysb, bosinst_data, any installp_bundle, and a pre/post script), then start the BOS install operation with smitty nim_mac_op using flags such as:

installp Flags: -agX
Remain NIM client after install: yes
Initiate Boot on Client: no (you will boot it from the HMC)
ACCEPT new license agreements: yes

Before booting, confirm the master built the boot artifacts:

Check /tftpboot for the SPOT boot image, the per-client symlink, and the client .info file.
Review lsnim -l <node> — it should show Cstate = BOS installation has been enabled.
Confirm the BOOTP entry exists in /etc/bootptab.

Kick the network boot with netboot -n <node> (CSM), or open SMS on the LPAR and boot from the network adapter. Watch progress on the console and power state:

Open the console: rconsole -rtn <node>
Poll power until the build finishes:
while true; do date; rpower -ln <node> query; echo; sleep 5; done

Build the Virtual I/O Servers (VIOS)

VIOS partitions are installed by NIM too, from a VIOS mksysb image plus a SPOT built from it. The flow:

List the managed LPARs to identify the IOServer partitions: lshwinfo -p hmc -c <hmc> (the IOServer rows carry the IOServer device type).
Define each VIOS as a CSM hardware device: definehwdev -d <vios> -H <hmc> PowerMethod=hmc, then set its remote transport with chhwdev -a RemoteCopyCmd=/usr/bin/scp RemoteShell=/usr/bin/ssh RemoteShellUser=padmin.
Define the NIM resources from the VIOS media: a bosinst_data, the mksysb image, and a spot built from that mksysb, e.g.:
nim -o define -t mksysb -a server=master -a location=/csminstall/nim/VIOS/mksysb_image vios_mksysb
nim -o define -t spot -a server=master -a source=vios_mksysb -a location=/csminstall/nim/VIOS/ vios_spot
For SAN-rootvg installs, pin the install disk by its physical location: read it with lsattr -El hdisk4 | grep -E "ww_name|lun_id" and set PHYSICAL_LOCATION (the Uxxxx...-Wwwn-Llun string) in the VIOS bosinst.data so BOS lands on the correct LUN.
Define the VIOS as a standalone NIM client and run the combined allocate-and-install in one step:
nim -o bos_inst -a source=mksysb -a group=vios_installation -a bosinst_data=<vios>_bid -a no_client_boot=yes <vios>
Power on and boot from network at the SMS menu (rpower -d <vios> on, rconsole -dn <vios>), entering the client IP, NIM server IP and subnet mask under IP Parameters.

After install, log in as padmin, set a password, accept the license with license -accept, install SSH and the multipath driver, then patch to the target VIOS level with updateios (mount the fix directory and run updateios -dev /mnt/<fixpack> -accept; confirm with ioslevel).

Configure VIOS virtual networking and storage

With VIOS running, bridge the physical network and carve out virtual disks for the client LPARs. Add /usr/local/bin to /etc/environment first, or CSM's updatenode will fail to find its helpers.

Create the Shared Ethernet Adapter so clients reach the real LAN:
mkvdev -sea ent3 -vadapter ent0 -default ent0 -defaultid 2
Bring up the VIOS network: mktcpip -hostname <vios> -inetaddr <ip> -interface en7 -netmask <mask> -start -gateway <gw>
Map each physical disk to a client through its virtual SCSI host adapter, naming the mapping clearly:
mkvdev -vdev hdisk0 -vadapter vhost0 -dev <client>_hdisk0 (repeat per client/vhost).

For redundancy, do the equivalent mappings on the second VIOS so each client has dual paths. Verify everything with lsdev -virtual and lsmap -vadapter vhost0 — the latter shows which backing device serves which client.

Common pitfalls

BOOTP/TFTP blocked: netboot silently stalls if the install VLAN, firewall, or a missing BOOTP relay drops the request. Confirm /etc/bootptab and that tftp in /etc/inetd.conf is enabled.
MAC mismatch: the MAC in the NIM client and /etc/bootptab must match the adapter the LPAR boots from — re-run getadapters if the NIC changed.
SPOT not rebuilt after updates: updating the lpp_source does not update the SPOT; run the SPOT update_all or the new boot image will be stale.
OpenSSL/OpenSSH version skew: install OpenSSL before OpenSSH and keep versions compatible, or sshd will not start.
Wrong SSH paths in csmconfig: point RemoteShell/RemoteCopyCmd at where AIX actually installed them (/usr/bin), not an assumed /usr/local/bin.
Installing onto the wrong LUN: for SAN rootvg, always pin PHYSICAL_LOCATION in bosinst.data or an overwrite install can wipe the wrong disk.

Verification checklist

Master health: lsnim -l master shows the master is configured; nim -o check <spot> returns clean.
Resources ready: each resource shows Rstate = ready for use in lsnim -l.
Boot artifacts: /tftpboot holds the SPOT image, client symlink and .info file.
Client install: after netboot, lsnim -l <node> returns to Cstate = ready for a NIM operation and the LPAR boots AIX.
CSM control: rpower -a query and updatenode -a reach every node over SSH.
VIOS: ioslevel reports the target level and lsmap -all shows every client mapping active.

Key Takeaways

A NIM install on AIX hinges on three resources — lpp_source (software), SPOT (network boot/runtime), and mksysb (cloneable backup) — served over BOOTP/TFTP.
CSM is end of life; use xCAT on current Power hardware for the same node-definition, power/console and NIM-orchestration role.
Keep node names, MAC addresses and /etc/hosts entries perfectly consistent across NIM, CSM and the HMC, or netboot fails silently.
Always rebuild the SPOT after updating its lpp_source, and pin PHYSICAL_LOCATION for SAN-disk installs to avoid wiping the wrong LUN.
VIOS remains current technology: install it from a VIOS mksysb via NIM, then bridge the LAN with an SEA and map virtual disks with mkvdev.

Frequently Asked Questions

What is the difference between lpp_source, SPOT and mksysb in NIM?

An lpp_source is a directory of installable software (AIX filesets and RPMs). A SPOT (Shared Product Object Tree) is built from an lpp_source and provides the network boot image plus the runtime the client uses during install. An mksysb is a full backup image of a reference system that you clone onto new machines. A fresh BOS install uses lpp_source + SPOT + bosinst_data; cloning uses mksysb + SPOT.

Is CSM still supported, and what replaced it?

No. CSM has been withdrawn from support. IBM's supported successor is xCAT, an open toolkit that defines nodes, controls hardware through the HMC/BMC, and drives NIM the same way CSM did. New AIX deployments on current Power systems should standardize on xCAT plus NIM.

Can I run a NIM install over the network without any CD?

Yes — that is the entire point. Once the master holds an lpp_source and SPOT (or an mksysb), clients boot from the network adapter via BOOTP/TFTP and install with no local media. You only need media once, to build the resources on the master.

Why does my NIM client hang at netboot?

The usual causes are a BOOTP/TFTP request that never reaches the master (wrong VLAN, firewall, or missing BOOTP relay across a router), a MAC address mismatch between the NIM client object and the booting adapter, or a missing /etc/bootptab entry. Verify the MAC with getadapters, confirm tftp is enabled in inetd, and check lsnim -l shows the install enabled.

For more AIX, NIM and Power systems walkthroughs, subscribe on YouTube @explorenystream.