Jon's Configuring Solaris Jumpstart Without a Name Service Lab

Configuring Solaris Jumpstart Without a Name Service

This lab will illustrate a very simple Solaris Jumpstart configuration suitable for users who do not use a Name Service (such as NIS or NIS+).

In this lab, we will convert a single-board-domain Sun Sparc or Ultra host into a combination boot, configuration, and installation server, with one other unconfigured (PROM level) Sun Sparc or Ultra as a Jumpstart client.

Hosts running Solaris on Intel (x86) require significantly different Jumpstart configurations involving boot diskettes and other methods. Please consult Sun documentation for instructions.

This lab utilizes a Solaris 7 Server Installation CD. Be advised that different Solaris versions (and sub-versions) may have different absolute pathnames on their CD-ROMs, so be sure to adapt accordingly.

Some Practical Advice

On your first attempts at building a Jumpstart server, it is highly recommended that the new client be located as close as possible to the server, if not right beside it. This is so that debugging and repair of malfunctioning files can be quickly and easily done.

Once you are satisfied that your client and server are completely configured, booting them over remote locations of the subnet (i.e. different floors of a building) will now be completely automatic, no longer requiring your interaction. Note that you will need to be present at the client to perform the PROM boot command.

It is important to note that a Boot Server relies on Reverse Address Resolution Protocol (RARP) to facilitate the booting of the client. A RARP packet cannot traverse a router. Thus, the client will need to boot from a Boot Server on its own subnet (note that some LAN switches can transport a RARP packet between subnets). By contrast, the Configuration and Installation Servers (if separate from the Boot Server) can be located on any other subnet that the client has a route to.

Configuring the Jumpstart Server

For the examples in this lab, the server's hostname is homer and the client's hostname is scully. Sustitute your desired host names as required.
On the server, log in as root superuser and insert the Solaris OS Installation CD.
Make sure that the server is in run level three:
```
who -r
```
The Jumpstart server must have a CDROM player and about 500MB of free space in one of its empty mounted partitions:
```
df -k
```
Read this carefully: For this lab, we will assume that the /export directory has 500MB of free space. You must determine the proper directory for your own server and adjust the pathnames in this lab accordingly!

Open a terminal window and run the following commands:


mkdir -p /export/install /export/config

cd /cdrom/sol_7_sparc/s0/Solaris_2.7/Misc/jumpstart_sample

cp -r * /export/config

cd ../../Tools

./setup_install_server /export/install

Don't stop now! Read the next paragraph.

While these commands begin spooling the Solaris OS into our server's new /export/install directory, we can proceed immediately to the next section for further configuration of the server. This is to better use our time since spooling of the OS may take from 20 to 50 minutes, depending on the speed of our CDROM player.

Configuring the Jumpstart Client

While the OS is spooling:

open another terminal window
make sure that the client's hostname and IP address are in the server's /etc/hosts file
share the server's /export/install and /export/config directories by adding these two lines to its /etc/dfs/dfstab file:
```
share -F nfs -o ro,root=scully /export/install
share -F nfs /export/config
```
make sure that the server's NFS daemons are running:
```
ps -ef|grep nfsd
```
If they are not running, start the daemons with:
```
/etc/init.d/nfs.server start
```
confirm that the shares are active with:
```
dfshares
```

go to the client and probe for its hard drives (at PROM level):


probe-scsi	[if just one scsi controller]
probe-scsi-all	[if more than one scsi controller]
probe-ide	[if on an ide controller on Sun architecture]

Using the disk target numbers found, write down the client's logical disk device names for future reference (i.e. c0t3, c0t0, c1t2, etc.).
Make note of the client's ethernet hardware (MAC) address by running this PROM command:
```
banner
```
Note that Sparc clients are sun4m architecture, while Ultra clients are sun4u architecture.

Proceed immediately to the next section.

Customizing the Jumpstart Server

We will now prepare the Jumpstart server with precise, custom instructions on how it will install the Solaris OS onto our Jumpstart client.

Create a file called /export/config/new_class, which will tell our server how to partition the client's disk(s) and layout the UFS file system on them. It will also tell our server to install the Entire Distribution With OEM installation cluster.

Enter the following into the new file, taking care to replace these example logical device names with the real ones found on the client. Here is an example for a dual disk client:


install_type		initial_install
system_type		standalone
partitioning		explicit
filesys			c0t3d0s0			48		/
filesys			c0t3d0s3			672		/usr
filesys			c0t3d0s4			233		/var
filesys			c0t3d0s6			free		/testdir
filesys			c0t1d0s0			132		swap
filesys			c0t1d0s1			free		/export
cluster			SUNWCall

Save and close /export/config/new_class.
Edit the /export/config/rules file and locate this line:
```
hostname	sample_host 	-	host_class	set_root_pw
```
Comment that line (to make it unreadable) and replace it with:
```
hostname	scully		-	new_class	set_root_pw
```
Save and close /export/config/rules.
Create a file called /export/config/sysidcfg. This new file will inform our server about our client's particular identity, including its root password. Actually, the client will have the same root password as the server until we change it after install.
Be sure to enter each line's case and syntax exactly as shown, substituting your actual time zone and network information as required.
Note that the line called network_interface contains curly braces and is one continuous line.

It is critical that you read the notes on root_password (below this example) before completing this file.


system_locale=en_US
timeserver=localhost
timezone=Canada/Pacific
name_service=NONE
root_password=
network_interface=le0 {hostname=scully ip_address=125.33.42.189 netmask=255.255.255.0}

Regarding the root_password line, read the following section carefully before saving and closing the /export/config/sysidcfg file:

Transplanting A Root Password

Keep the /export/config/sysidcfg file open in an editor
Open a different window and display the server's /etc/shadow file
If our encrypted root password shown there contains a period and/or a slash, it will be unusable for the password transplant we are about to perform. To fix this:
- change the root password
- display the /etc/shadow file to confirm that all periods and slashes are gone from the encrypted password
- Perform this password change as many times as needed to remove periods and slashes
- Trick: you can even keep using the same password over and over again, since the encryption changes each time regardless of the original characters
Use the mouse to highlight root's encrypted thirteen character password
Paste the password into the /export/config/sysidcfg file's root_password= line

Customizing the Server (cont.)

Save and close the /export/config/sysidcfg file
Change to the /export/config directory
Run the following command to confirm that the syntax of files is correct. Watch for valuable screen output regarding any errors.
```
./check
```
If the syntax was correct, a file called /export/config/rules.ok is generated as confirmation. Screen output will confirm that our new_class file has been okayed.
Verify that rules.ok now exists:
```
ls -l /export/config/rules.ok
```
If it does, we are ready to proceed to the next section. If it does not, we must retrace all of our steps in this lab section.

Initializing the Jumpstart Server

A Jumpstart Client could be served by three separate Jumpstart servers (boot, configuration, and installation). We will simplify this lab by instructing our client to access only one server for all three tasks. We must enter these instructions onto the boot server, which will be the first source of information for the new client when it boots.

When the Solaris OS software has completed spooling onto the Jumpstart server, we are ready to proceed:


cd /export/install/Solaris_2.7/Tools

Run the following command (note that it is one continous line, not two) and substitute appropriate information as needed:


./add_install_client -e 8:00:20:2C:97:70 -s homer:/export/install -c homer:/export/config -p
homer:/export/config scully sun4u

Syntax Example (one whole line, no line wraps): ./add_install_client -e [client's ethernet address] -s [server's /export/install directory] -c [server's /export/config directory] -p [server's /export/config directory] [client's hostname] [client's architecture]

Handy Tip: Edit a file called my_install and cut-and-paste this long ./add_install_client line into it for future use.

Our Jumpstart server configuration is now complete. Proceed to the next section.

Jumpstart Client Behavior

At this point, assuming all has gone as required on the server, we have only one step to perform on the client. Read this entire section before proceeding with the actual bootup command shown in the next section.

When the client is issued its proper boot command, it will broadcast its ethernet address onto our subnet in hexadecimal format. Our Jumpstart server will recognize the client's ethernet address and respond with all of our defined bootup and system parameters.

The client's screen will show a burst of memory activity indicated by rapidly added hexadecimal digits showing the transfer of critical data, such as the kernel.

After a device configuration period, the client will then start an OpenWindows session with a single, small window in the upper left corner of the bluish-gray screen. Jumpstart does not require any human intervention in any way, so do not enter any keystrokes on the booting client. There will be no need to enlarge this small window, as we will soon see.

The window will begin to inform us of the installation's progress. As this is happening, all of the client's hard drives specified in the Jumpstart files should begin to show activity as they are partitioned and file systems are created on them.

Eventually, the actual OS installation will begin, and a countdown of package descriptions will appear in the now-enlarged window as they are being installed.

Booting the Jumpstart Client

When observing the client's Jumpstart bootup, it will be easy to correct most problems since the window will constantly be monitoring boot progress.

If the problem exists in our rules or sysidcfg files, the window will indicate which line and character it is unable to understand. We can thus go to the Jumpstart server and correct the difficulty.

Now that you have read the items above, begin the Jumpstart session on the client by running the following PROM command:


boot net - install

Carefully observe all aspects of the client's behaviour, as described above.

Starting Over If Errors Occur

If you have experienced any errors and have corrected them, restarting the client's Jumpstart bootup is unfortunately not as simple as running the command over again.

You must run these lines again, in order:


cd /export/install/Solaris_2.7/Tools


./add_install_client -e 8:00:20:2C:97:70 -s homer:/export/install -c homer:/export/config -p
homer:/export/config scully sun4u

Then, on the client:
```
boot net - install
```

Click Here to jump to my Custom Solaris System Administration Labs page.