In the Churchill framework, the Churchill server itself provides assorted network and storage services to servers called Alpher and Bethe. We could usefully think of Churchill+Alpher+Bethe as “Production Site 1”: self-contained and working happily enough.
But what if a meteorite (or, slightly less spectacularly, a flood) takes out Site 1? That would be the end of all database service provision and your business would probably go bust. In many cases, large businesses will seek to mitigate the risk of disaster like this by having a Site 2 that has copies of all the Site 1 servers that can be activated in mere minutes or seconds, should Site 1 go down for any length of time. This is the concept of the standby site.
Not all businesses will use standbys: they cost a lot for a start. You need double the hardware budget… and double the Oracle licensing fees, which is probably worse! But I think it’s useful to know how to create and operate a standby database in an Oracle context anyway, and accordingly, the Churchill framework makes provision for a ‘second data centre’, where servers Geiger and Dirac run as copies of Alpher and Bethe.
Just one issue arises, though: if Alpher and Bethe use Churchill’s fake ASM disks for their database storage, where should Geiger and Dirac find their fake disks? You can’t have them also using Churchill, because that would be the equivalent of both data centres using the one SAN, providing no redundancy at all! Enter Attlee…
Attlee is essentially a copy of Churchill, built with much the same hardware resources and offering much the same storage and network services to the rest of the framework. But specifically, he acts as the provider of fake-ASM-disks to Geiger and Dirac.
Put another way: as Churchill is to our primary data processing centre, so Attlee is to our secondary. As such, Attlee is practically a clone of Churchill and is set up very similarly. It’s not exactly the same as Churchill, because it’s not going to be hosting the operating system and Oracle software as Churchill does. But as far as shared, network-capable storage and the provision of NTP, DNS, DHCP and NFS network services, you’d be hard-pressed to tell them apart.
2.0 Hardware Resources
Attlee needs to be built in almost the same way as Churchill was originally. Specifically, this mandates:
- 1 x CPU
- 512MB RAM
- 1 x host-only network interface
- 60GB Hard disk
- 1 x DVD drive
The difference between Attlee and Churchill is that Churchill required 2 DVD drives where Attlee only needs one. Also, Churchill needed a 75GB hard drive, but Attlee can make do with 60GB. That’s because Churchill serves all Oracle software to other servers on the network -database and Cloud Control- whereas Attlee doesn’t. Attlee can thus save about 15GB just because he doesn’t have to store the Grid, Database and Cloud Control software on his hard disks.
The network interface that Attlee uses must be the one that Churchill uses, too (that is, it must be on the same subnet as Churchill. In plain English, Attlee has to be able to talk to Churchill over the network). In VirtualBox, that’s going to mean Attlee is built to use the ‘vboxnet0’ host-only interface, rather than the vboxnet1 one that Alpher & Bethe use.
In case it isn’t obvious from what I’ve written so far: Attlee gets away with a single DVD drive because he will get his Kickstart file from the Churchill server, over the network, as he first boots. Churchill must therefore be running in the background before Attlee can be built.
I should also mention that Attlee must be built with the same software that you used to build Churchill with. If your Churchill runs with Scientific Linux 6.6, therefore, you can’t have Attlee running with Red Hat 6.9!
3.0 The Attlee VM
I won’t exhaustively document how you build Attlee in the virtualization tool of your choice: by the time you get to this point in the Churchill framework story, you’ve built enough virtual machines already to know what you’re doing! Instead, I’ll just show you the VirtualBox summary screen for my Attlee box:
Notice the key features here: just 512MB memory; one DVD drive, populated with a CentOS 6.8 distro (because that’s what I built my Churchill server with); one hard drive of just 60GB; and one network card, using vboxnet0.
You will also see from that screenshot that I’m building Attlee with Churchill, Alpher, Bethe and Wilson all running in the background. That is not essential: the only VM that is actually required to be running before Attlee can be built is Churchill itself.
4.0 Building Attlee
Like all the other servers in the Churchill framework, Attlee is built with a hefty sprinkling of Kickstart magic, making the build process almost entirely automatic. Just power on the server and press <TAB> when the boot menu appears. Onto the end of the text which is already there, you append the Attlee ‘bootstrap line’ which is simply:
Your boot screen therefore ends up looking like this:
If you are using something other than CentOS 6.8, you do not need to specify that on the bootstrap line. That is, if you were building Alpher with (say) Scientific Linux 6.7, you would be expected to add “&distro=sl&version=67” to the bootstrap line; but if you were building Attlee with Scientific Linux 6.7, your bootstrap line remains exactly as shown above: no distro or version additions are required.
The reason for this is that Attlee must be built with full-install media (i.e., the DVD1 of the distro release, not the netinstall or live CD media) and therefore fetches nothing by way of software from Churchill itself. Therefore, it doesn’t need to specify distro and version data to help it find that software on Churchill.
But bear in mind what has already been stated: this doesn’t mean you can build a Scientific Linux Attlee whilst using an OEL Churchill. Distro and version actually have to be identical between Churchill and Attlee… it’s just that it’s you who has to be sure that’s the case, and Churchill’s not going to check up on you if you aren’t telling the truth! (But things won’t work if you aren’t!)
Anyway, once you’ve typed the bootstrap line, press [Enter] and everything else will then just happen automatically.
You will see this screen for quite a while as things conclude:
This takes several minutes to complete because it’s at this point that Attlee is creating a set of 8 5GB ‘fake hard disks’ that Geiger and Dirac can later use as ASM disks. It’s the need for 40GB of ASM disks in this way that makes it compulsory to create Attlee with at least a 60GB hard disk. Anyway: be patient during this stage of proceedings.
Eventually, you’ll see this:
Press [Enter] at this point and your new VM will reboot (you may need to manually ‘eject’ the O/S install disk for it to be able to boot normally).
When it comes back up, you can log on as the user root, password oracle. You will note that Attlee, like all Churchill framework servers, is rather minimalist in appearance:
It’s command-line only and absolutely no GUI fripperies are provided!
That screenshot tells you, though, that Attlee is not just sat there doing nothing: it shows me listing the contents of the /dbdata directory and discovering that there are 8 files sitting there, each of 5GB. Those are the ASM disks I mentioned previously.
If you also type commands such as this:
pgrep bind; pgrep ntpd
…you’ll get a response along these lines:
[[email protected] ~]# pgrep bind; pgrep ntpd 1017 1308
…which shows that Attlee is running Bind (and thus acting as a DNS server in its own right) and NTP (the network time protocol). The numbers returned are the process IDs of the respective applications. It is, in other words, demonstrably running a range of network and storage services, just as Churchill does -but with a different audience of clients in mind!
You might also want to issue this command:
[[email protected] ~]# ip addr 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00 inet 127.0.0.1/8 scope host lo inet6 ::1/128 scope host valid_lft forever preferred_lft forever 2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP qlen 1000 link/ether 08:00:27:a7:5d:6f brd ff:ff:ff:ff:ff:ff inet 192.168.8.251/24 brd 192.168.8.255 scope global eth0 inet6 fe80::a00:27ff:fea7:5d6f/64 scope link valid_lft forever preferred_lft forever
It shows you that the IP address to use (if you wanted to connect to Attlee via SSH, for example) is 192.168.8.251. Keep that in mind -though, in fact, there is seldom a need to ever connect to Attlee directly, since there is no requirement to copy any Oracle software to it.
In this article, you’ve seen how easy it is to build, effectively, a clone of Churchill -by supplying a simple bootstrap line at the point it first boots up. Everything after that point is automated for you and Attlee ends up acting as a secondary DNS, DHCP, NTP and NFS server, able to supply those essential network services to machines which we will go on to construct as clones of Alpher and Bethe.
If you are not going to practise running Data Guard in a simulated ‘secondary data centre’, therefore, you do not need to build Attlee. But if you are, Attlee is an essential first step -and, hopefully, you’ve just seen how trivially easy the Churchill framework makes building it.