sudo find . -type d -exec chmod 755 {} \;
sudo find . -type f -exec chmod 644 {} \;
sudo chgrp -R www-data .
sudo chmod -R g+w .

The first rewrite condition checks to see if the file exists, and only if it does, will it redirect all traffic to it. The second rewrite condition is there to prevent an infinite loop, by only redirecting traffic to files other than maintenance.html.

RewriteEngine On

RewriteCond %{DOCUMENT_ROOT}/maintenance.html -f
RewriteCond %{REQUEST_FILENAME} !/maintenance.html
RewriteRule ^.*$    /maintenance.html [L]

There’s a lot of buzz brewing about it, so I wanted to give it a try with PHP on my development Mac. The following is how I went about installing Apache, PHP and MongoDB on Snow Leopard. You must have installed the Xcode developer tools (found on the Snow Leopard install DVD) and MacPorts for this to all work.

First, let’s install Apache:

sudo port install apache2

Nice and simple. Now we can move onto PHP:

sudo port install php5 +apache2 +pear

To enable PHP for Apache:

cd /opt/local/apache2/modules
sudo /opt/local/apache2/bin/apxs -a -e -n "php5" libphp5.so

I like to make some alias commands for starting, restarting and stopping Apache:

mate ~/.bashrc

alias apache-start="sudo /opt/local/apache2/bin/apachectl start"
alias apache-restart="sudo /opt/local/apache2/bin/apachectl restart"
alias apache-stop="sudo /opt/local/apache2/bin/apachectl stop"

source ~/.bashrc

Now we can make a few changes to the Apache config so that we can use our Sites directory:

sudo mate /opt/local/apache2/conf/httpd.conf

I’m using Textmate here (mate), but you can use any editor you wish, like nano.

Change the DocumentRoot:

DocumentRoot "/Users/davidwinter/Sites"

Then update the <Directory> path to the updated DocumentRoot path.

<Directory "/Users/davidwinter/Sites">

We also want to enable index.php as a directory index file:

<IfModule dir_module>
    DirectoryIndex index.html index.php
</IfModule>

And then add the PHP mime type:

<IfModule mime_module>
    ...
    AddType application/x-httpd-php .php
    AddType application/x-httpd-php-source .phps
</IfModule>

Now we need to setup the php.ini file:

sudo cp /opt/local/etc/php5/php.ini-development /opt/local/etc/php5/php.ini

sudo mate /opt/local/etc/php5/php.ini

My timezone is for London:

date.timezone = Europe/London

Now we can get onto installing MongoDB (this will install the latest stable version as of time of writing – 1.2.1):

sudo port install mongodb

And then the PHP MongoDB extension:

sudo pecl install mongo

You’ll need to add the extension to the bottom of your php.ini file:

sudo mate /opt/local/etc/php5/php.ini

extension=mongo.so

Now startup Apache using the alias created earlier:

apache-start

If you create a file in your Sites directory, called test.php, and add the following to it:

<?php phpinfo(); ?>

Then visit the page in your browser; http://localhost/test.php

You can then scroll down the page and you should see a section titled ‘mongo’. This means the extension is working!

Now we need to startup MongoDB:

mkdir -p ~/data/db
mongod --dbpath ~/data/db/

Almost there, now a simple MongoDB test in PHP:

<?php
// Connect:
$connection = new Mongo();
// Select database:
$db = $connection->my_db;
// Select collection:
$films = $db->films;

$frwl = array(
    'title' => 'From Russia With Love',
    'year' => 1963,
    'actor' => 'Sean Connery'
);
// Save array to collection:
$films->insert($frwl);

$gf = array(
    'title' => 'Goldfinger',
    'year' => 1964,
    'actor' => 'Sean Connery',
    'girl' => 'Pussy Galore'
);

$films->insert($gf);

// Count documents in collection:
if ($films->count()): ?>
<table>
    <tr>
        <th>Title</th>
        <th>Year</th>
        <th>Actor</th>
        <th>Girl</th>
    </tr>
    <?php foreach ($films->find() as $film): ?>
    <tr>
        <td><?php echo $film['title']; ?></td>
        <td><?php echo $film['year']; ?></td>
        <td><?php echo $film['actor']; ?></td>
        <td><?php echo $film['girl']; ?></td>
    </tr>
    <?php endforeach; ?>
</table>
<?php endif;
?>

Very exciting stuff. More to follow.

sudo mate /etc/httpd/users/yourusername.conf

Now you’ll want to enable Apache to follow symbolic links:

Options Indexes MultiViews FollowSymLinks

And to allow .htaccess overriding:

AllowOverride All

The file should then look like:

<Directory "/Users/yourusername/Sites/">
    Options Indexes MultiViews FollowSymLinks
    AllowOverride All
    Order allow,deny
    Allow from all
</Directory>

Now in System Preferences, stop and start ‘Personal Web Sharing’. Things should work perfectly now.

Now we’re going to install Subversion 1.4.0 from source so that it can be access via Apache with authentication.

Installing Subversion

As we’ve built Apache from source, we’ll need to do the same for Subversion in order to get the Apache 2 modules mod_dav_svn and mod_authz_svn.

wget http://subversion.tigris.org/downloads/subversion-1.4.0.tar.gz
tar xvfz subversion-1.4.0.tar.gz
cd subversion-1.4.0/
./configure --prefix=/usr/local --with-apxs=/usr/local/apache2/bin/apxs
make
sudo make install

This will also add the relevant LoadModule directives into your Apache 2 configuration for you.

Creating your repository

Now, create your Subversion repository:

svnadmin create /home/yourusername/subversion/repos

We have to make that repository owned by Apache so that it can be accessed via the web:

sudo chown -R apache /home/yourusername/subversion/repos

Authentication File

Now create a user/password file for authentication:

htpasswd -cm /home/yourusername/subversion/dav_svn.passwd davidwinter

When prompted, enter your password.

Configuring Apache

Edit your /usr/local/apache2/conf/httpd.conf file with the following placed at the end:

<Location /svn>
  DAV svn
  SVNPath /home/yourusername/subversion/repos

  AuthType Basic
  AuthName "Subversion Repository"
  AuthUserFile /home/yourusername/subversion/dav_svn.passwd
  Require valid-user
</Location>

If you want access control based on different users, add the following line after the Require valid-user line:

AuthzSVNAccessFile /home/yourusername/subversion/svn_access_control

Save the file. Start Apache. To find out what you need to put in the svn_access_control file, read my previous Subversion authentication article here. for params.

1. You want to host a Rails application using Mongrel via Apache and mod_proxy_balancer.
2. You’re studying in a Website administration module for your 3rd year Software Engineering degree :)

Seriously though, if you don’t want to use mod_proxy_balancer, just do a normal apt-get install of Apache 2 and you’ll be fine. mod_proxy_balancer is only available for Apache 2.2, and currently, that’s not available from the Ubuntu repositories via apt-get.

This article only covers installing Apache 2.2 – I’ll write another one for getting Subversion and PHP working shortly afterwards.

Workspace

If you’ve not got the build-essential package installed yet:

sudo apt-get install build-essential

It’s best to keep all of the source files in a seperate directory so they don’t mess up your home directory.

cd
mkdir src
cd src

Zlib

So that Apache can compress output to browsers that support it, we’re going to install Zlib first of all:

wget http://www.zlib.net/zlib-1.2.3.tar.gz
tar xvfz zlib-1.2.3.tar.gz
cd zlib-1.2.3/
./configure --prefix=/usr/local
make
sudo make install

Apache 2.2

Now download the Apache 2.2 source files:

cd ..
wget http://apache.rmplc.co.uk/httpd/httpd-2.2.3.tar.gz

Extract and move into the directory:

tar xvfz httpd-2.2.3.tar.gz
cd httpd-2.2.3/

Now to configure the build of Apache 2.2 that we want:

./configure --prefix=/usr/local/apache2 --enable-mods-shared=all --enable-deflate --enable-proxy --enable-proxy-balancer --enable-proxy-http

Besides setting the modules we’d like installed, and the location of the install, this paramater --enable-mods-shared=all is telling Apache 2.2 to build modules so that they can be dynamically loaded when it is started. This means, we can add further modules to our Apache 2.2 install when we like – as we will do with the Subversion modules and PHP.

Once the configuration is complete:

make
sudo make install

Let’s test that it’s working:

sudo /usr/local/apache2/bin/apachectl start

Now navigate to http://localhost and you should see a message saying “It works!”.

Stop Apache:

sudo /usr/local/apache2/bin/apachectl stop

Apache at start-up

Now let’s get Apache to start at boot time automatically:

sudo cp /usr/local/apache2/bin/apachectl /etc/init.d/apachectl
sudo chmod +x /etc/init.d/apachectl

What we’re doing here is copying the Apache Control script into the start-up directory.

We just need to add a few lines to the file for it to work nicely:

sudo nano /etc/init.d/apachectl

Add the followinig, so the top of the file looks like:

#!/bin/sh
#
# chkconfig: - 85 15
# description: Apache is a web server.

Save the file.

Now we need to register it with the start-up manager:

sudo /usr/sbin/update-rc.d apachectl defaults

Securing Apache

It’s also a good idea to create a dedicate Apache system user account. It’ll make your install much more secure.

sudo adduser --system apache

Now we just need to make sure that Apache runs under this user. We do that by editting the configuration file:

sudo nano /usr/local/apache2/conf/httpd.conf

You need to find the lines that say:

User daemon
Group daemon

And change them so they look like:

User apache
Group nogroup

Save the file.

Now, let’s start Apache:

sudo /usr/local/apache2/bin/apachectl start

Now to check it’s running under the new user, apache:

ps -aux | grep httpd

If you see the word apache in there, it’s working.

Check it’s all working

Now just reboot the system and before logging in, check on another machine by visiting the servers IP in the web browser and you should see the “It works!” message. This means Apache started up correctly automatically.

Building Apache 2.2 from source. Done.

This updated version is very similar to the 5.10 how-to, however, there are a few changes required. The following changes have been made:

• Setting up the Multiverse and Universe repositories
• The packages to install Ruby
• Setting a symbolic link for Ruby
• Updating rubygems
• Clearing the rubygems cache

Other than those, the rest of the how-to is the same as the Breezy how-to.

This how-to assumes that you have a clean install of Ubuntu Dapper (I’m not currently using Ubuntu Dapper Server, just the basic desktop install).

The first thing to do, is get ssh installed so that if you like, you can connect and do all of this remotely.

sudo apt-get install ssh

There are some packages that are needed that aren’t in the default repositories for apt, so you have to enable them manually. Universe and Multiverse are needed.

To enable them, open up the Synaptic Package Manager

1. Settings
2. Repositories
3. Add
4. Ensure that ‘Ubuntu 6.06 LTS’ is the selected ‘Channel’
5. Check ‘Community maintained (Universe)’
6. Check ‘Non-free (Multiverse)
7. Click OK and let it rescan the servers.

You can then close Synaptic. apt is now all set up ready for installing the packages we need.

Before we start installing the packages we want, do a system update:

sudo apt-get update

Ruby

All on one line:

sudo apt-get install irb libdbm-ruby libfcgi-ruby1.8 libgdbm-ruby libmysql-ruby libopenssl-ruby libruby1.8-dbg ri ruby1.8-dev

In order for Ruby to work ok, do the following:

sudo ln -s /usr/bin/ruby1.8 /usr/bin/ruby

This will add a symbolic link into your /usr/bin directory so that the command ruby works, as opposed to ruby1.8.

MySQL Server

sudo apt-get install mysql-server

During this install, a Postfix config screen will appear. Select OK and then “No configuration”.

Ruby Gems & Rails

This is the standard way of installing ruby applications.

Need to download it directly from its web site:

wget http://rubyforge.org/frs/download.php/5207/rubygems-0.8.11.tgz

Then extract it:

tar xvfz rubygems-0.8.11.tgz

Move into the extracted directory:

cd rubygems-0.8.11

Run the setu-p program:

sudo ruby1.8 setup.rb

Update all installed gems on the system:

sudo gem update --system

Take note that there are two dashes preceding system.

Now that Ruby Gems is installed, we can install Rails. However, I encountered problems with this and had to clear my rubygems cache first. Do the following:

gem env gemdir

This will output a path location which you’ll need to use for the next command. For me, it was and probably is the same for you, /usr/lib/ruby/gems/1.8

sudo rm ABOVE_PATH/source_cache

This will clear your rubygems cache. Now you shouldn’t have any problems with installing rails.

sudo gem install rails -y

Apache 2

Next is the web server I’m using. Apache 2. The following command will install Apache 2, FastCGI, FCGI, PHP 5 with MySQL functionality. PHP isn’t needed for Ruby or Rails, but I’m including it so that I can run PHP apps…

sudo apt-get install apache2 libapache2-mod-fcgid libapache2-mod-fastcgi libapache2-mod-php5 php5-mysql

Once that’s done, we’ll need to enable the Apache mods we’ll be using:

sudo a2enmod fcgid
sudo a2enmod fastcgi
sudo a2enmod rewrite

You’ll notice I’ve installed two different types of Fast CGI. That’s because at some point I want to try them both out. However, at the moment, I’ve only had success with getting FastCGI working decently.

Restart Apache to make sure all is well.

sudo /etc/init.d/apache2 restart

FastCGI

I thought FastCGI would have been installed after doing the libapache2-mod-fastcgi – but for some reason, you have to install it manually.

In order to configure and build from the source files, you need to download some basic files:

sudo apt-get install build-essential

Then, grab the FastCGI files from the web site:

wget http://fastcgi.com/dist/fcgi-2.4.0.tar.gz

Extract:

tar xvfz fcgi-2.4.0.tar.gz

Move into the directory:

cd fcgi-2.4.0

Configure the installer:

./configure

Install:

sudo make install

Now, that is all of the Apache and FastCGI files installed. Later, we’ll need to configure it all.

Webmin

Webmin is ugly, but it works, and it lets us configure Apache and the Nameserver easily.

Go to http://www.webmin.com/ and download the latest version of webmin in tar.gz format.

Once downloaded, extract it (filename may vary depending on the version you download):

tar xvfz webmin-1.260.tar.gz

Move into the directory:

cd webmin-1.260

Run the set-up program:

sudo ./setup.sh /usr/local/webmin

You can use the default settings for this, or change them if you know what you’re doing. Be sure to set a password you can remember.

At the end of the set-up you’ll be given an address to use to connect to webmin. Remember this! and go to it straight away and login.

Do the following to configure Webmin to work with Apache: 1. At the top, click on the “Servers” link. 2. Select Apache Webserver. 3. Select Module Config. 4. Set the following values: * Apache Server Root – /etc/apache2 * Path to httpd executable – /usr/sbin/apache2 * Path to httpd.conf – /etc/apache2/httpd.conf * Command to start Apache – /etc/init.d/apache2 start * Command to stop Apache – /etc/init.d/apache2 stop

Save these settings.

Nameserver

I’m no DNS expert, so this is very vague and I suggest you go read a howto on DNS… here’s one I used to complete this part.

This will be different depending on your set-ups. For me, I have my domain name pointing to my web server in America that hosts http://commanderbond.net

On the server, there, I have the DNS pointing to my Internet IP at home, here in the UK.

The nameserver I’m using is Bind.

sudo apt-get install bind9

Once that’s installed, we need to configure it in Webmin. 1. Click the “Servers” link. 2. Select BIND DNS Server. 3. A message will appear about a configuration file. Select the 3rd option “Setup as an internet name server, but use Webmin’s older root server information” 4. Create a Master Zone and enter the following details: * Domain Name – yourdomain.com * Email – you@anemail.com 5. Click on “Create”. 6. Click on the “Address” link. 7. Create a new Address record using the following: * Name – yourdomain.com. (including the trailing dot) * Address – your Internet IP address 8. Click on “Create”. 9. Go to the Module Index. 10. Click on “Apply Changes”.

Set-up your web site

You’ll need somewhere to store your web site files, so I suggest to first of all create a public_html directory in your user directory.

mkdir ~/public_html

Now we’ll create a test HTML file to check all is working so far.

nano ~/public_html/index.html

Inside it put the following:

<p>Hopefully you can see this...</p>

Save the file using Control O and then Control X to quit Nano.

Now, set the permissions of the file so it’s visible to the world:

chmod 644 ~/public_html/index.html

In Webmin, go to the Apache configuration.

Create a new Virtual Server with the following: * Document Root – home/yourusername/public_html * Server Name – yourdomain.com

Save the settings. Now restart Apache:

sudo /etc/init.d/apache2 restart

Now visit http://yourdomain.com/~yourusername/ and you should see:

Hopefully you can see this…

If so, excellent! If not, hmmm… maybe you didn’t follow everything? or I made a mistake somewhere… leave a comment below.

Take a 5 minute break!

Refreshed? Right. Moving on…

phpMyAdmin for MySQL management

Go to http://www.phpmyadmin.net/home_page/index.php and download the latest stable release of phpMyAdmin in tar.gz format.

Extract:

tar xvfz phpMyAdmin-2.7.0-pl2.tar.gz

Move the directory to some place helpful:

mv phpMyAdmin-2.7.0-pl2 ~/phpmyadmin

Move into that directory:

cd ~/phpmyadmin/

Create a new configuration file:

cp config.default.php config.inc.php

Change the authentication mode to http

gedit config.inc.php

Change this line:

$cfg['Servers'][$i]['auth_type'] = 'config';

…to this line:

$cfg['Servers'][$i]['auth_type'] = 'http';

Save the file.

Back in the command line, we need to set the root password, because by default, there isn’t one!

mysql -u root

You’ll then enter the MySQL console. Enter the following:

UPDATE mysql.user SET Password=PASSWORD('newpasswordhere') WHERE User='root';

This will set the root password. Now flush the privileges:

FLUSH PRIVILEGES;

Now exit:

exit

Now, we want phpMyAdmin accessible on the server ‘globally’. So that it doesn’t matter what address we’re using, we’ll still be able to access it.

In Webmin, under Apache Webserver: 1. Select “Default Server” 2. Aliases and Redirects 3. Under “Document directory aliases” enter /phpmyadmin/ into the first text box, and /home/davidwinter/phpmyadmin/ into the box to the right of that one.

Save, and in the Terminal restart apache:

sudo /etc/init.d/apache2 restart

Go to http://yourdomain.com/phpmyadmin/

Login in using “root” and the password you set in the MySQL console.

You can do any MySQL configuration here. For me, I restored my Typo database for this blog from a backup.

FastCGI configuration with a Rails application

This part is what gets a Rails app running really fast.

You’ll need to configure the FastCGI config file:

sudo nano /etc/apache2/mods-enabled/fastcgi.conf

Here is my config file:

<IfModule mod_fastcgi.c>
  #FastCgiWrapper /usr/lib/apache2/suexec2
  FastCgiIpcDir /var/lib/apache2/fastcgi
  FastCgiConfig -maxClassProcesses 2 -maxProcesses 2 -minProcesses 2 -processSlack 2
  FastCgiServer /home/davidwinter/typo/public/dispatch.fcgi -idle-timeout 120 -processes 2 -initial-env RAILS_ENV=production
</IfModule>

The following line of the above:

FastCgiServer /home/davidwinter/typo/public/dispatch.fcgi -idle-timeout 120 -processes 2 -initial-env RAILS_ENV=production

Is important. You need to specifiy a line like this for each Rails app you’ll be using under FastCGI.

Now, in your Rails application directory check that in public/.htaccess has this line:

AddHandler fastcgi-script .fcgi

And, that in the rewrite rules section, it has this:

RewriteRule ^(.*)$ dispatch.fcgi [QSA,L]

…instead of:

RewriteRule ^(.*)$ dispatch.cgi [QSA,L]

Notice .fcgi instead of .cgi

And that’s about it!

Give Apache one final restart:

sudo /etc/init.d/apache2 restart

And you should now have everything working.

As I said, any problems, leave a comment and I’ll try and help.

Please welcome on stage the Apache2 mod, authz_svn…

If you followed my other howto, you’ll have all the pre-requisites for this.

First of all, we need to create an Access Control file.

sudo nano /etc/apache2/svn_access_control

In this file, you’ll want to put some rules. I’ll first of all go over these and then provide some examples.

Permissions

There are only two types of permission:

• Read only – r – a user can check-out a copy of a project.
• Read and Write – rw – a user can check-out and commit changes to a project.

Users

These are the same usernames that you have set in your password file that you created in the previous howto. You can always add more users to this file using:

sudo htpasswd2 -m /etc/apache2/dav_svn.passwd bill

When prompted, enter the password for the user.

Repository Location

You specify the above rules in certain locations for the repository. These go between square brackets.

[/]

The above will specify rules for the root of the repository.

[/wowapp/trunk]

The above will specify rules for a project named ‘wowapp’ in the trunk location.

User Groups

You can create groups of users and then use those for rules. You do this under a special heading in square brackets:

[groups]
mygroup = dave, mike

This will create a group called ‘mygroup’ which ‘dave’ and ‘mike’ belongs to.

And now for some examples.

Examples

[groups]
team = bob, bill
devteam = bob, barry, brett

[/]
@team = r
bob = rw

[/wowapp/trunk]
@team = r
@devteam = rw
brenda = rw

In this example:

• Created a group team which has two members; bob and bill.
• Created another group, called devteam which has three members; bob, barry, brett.
• In the root of the repository, I’ve given the group team read permissions.
• Also, in the root, bob has read and write permissions.
• In the trunk of wowapp, the group team has read permission.
• Also, the devteam group has read and write permissions.
• And another user, called brenda has read and write permissions.

Once you’ve created your desired access controll file, save the changes in nano by hitting CTRL O, hit enter to save the name, then CTRL X to quit Nano.

We just need to now link this access control file with our Subversion set-up.

sudo nano /etc/apache2/mods-enabled/dav_svn.conf

Here’s the example from the previous how-to:

<Location /svn>
  DAV svn
  SVNPath /home/svn

  AuthType Basic
  AuthName "Subversion Repository"
  AuthUserFile /etc/apache2/dav_svn.passwd
  Require valid-user
</Location>

All you need to add is the following line:

AuthzSVNAccessFile /etc/apache2/svn_access_control

So that the file looks like this:

<Location /svn>
  DAV svn
  SVNPath /home/svn

  AuthType Basic
  AuthName "Subversion Repository"
  AuthUserFile /etc/apache2/dav_svn.passwd

  AuthzSVNAccessFile /etc/apache2/svn_access_control

  Require valid-user
</Location>

Save the file, and then restart Apache2:

sudo /etc/init.d/apache2 restart

You should now have access control working for Subversion over Apache2.

I’m assuming you have Apache 2 already set-up. The only extra packages to download and install are subversion and libapache2-svn.

sudo apt-get install subversion libapache2-svn

This will download and install Subversion and the SVN module for Apache 2. The module itself uses WebDAV to transmit files between Subversion – so this means everything can go across port 80 without the hassle of having to worry about a firewall.

The install should automatically enable the module, but just to check:

sudo a2enmod dav_svn

It should come up saying it’s already enabled. If not, it will enable it for you.

You’ll need to configure Apache now:

sudo nano /etc/apache2/mods-enabled/dav_svn.conf

Edit the file to look something like this:

<Location /svn>
  DAV svn
  SVNPath /home/svn

  AuthType Basic
  AuthName "Subversion Repository"
  AuthUserFile /etc/apache2/dav_svn.passwd
  Require valid-user
</Location>

Change /home/svn to whatever the location of your repository is. If you haven’t created one yet, then do:

sudo mkdir /home/svn
sudo svnadmin create /home/svn

Now, you need to make Apache the owner of the repository:

sudo chown -R www-data /home/svn

To secure Subversion, do the following to create a password file:

sudo htpasswd2 -cm /etc/apache2/dav_svn.passwd bob

Replace bob with whatever username you want to use, and then when prompted enter a password.

Now restart Apache:

sudo /etc/init.d/apache2 restart

That should now all be set-up. You can try it by visiting your server http://you.server/svn. You should get a username/password dialog which you enter the details you created.

First of all, I updated the DNS records on my American server (which manages this domains DNS) so that it included a wildcard record.

*.davidwinter.me.uk. A 123.456.789.000

This means that any request to a sub-domain gets forwarded onto my server here at home. It’s a ton easier than having to set up each sub-domain a separate name record.

However, my good friend Greg told me that it’s important to also include a record for the domain name itself:

davidwinter.me.uk. A 123.456.789.000

With that all set up, and changes applied – I moved onto configuring my server at home.

I won’t bore you with all the problems I had getting this set-up correct. But in a sentence, the problem I was having was that only the first virtual server was displayed regardless of what sub-domain I used.

The solution?

In the Apache config file (httpd.conf), place this at the very top:

NameVirtualHost 192.168.0.1:80

Where 192.168.0.1 is the internal IP of your server running Apache.

Then, for each virtual host entry in the configuration file, set them up using:

<VirtualHost 192.168.0.1:80>

Using the same internal IP you specified in NameVirtualHost.

Save the file and restart Apache. All should work fine.

For my set-up, I still added DNS records for the sub-domains locally on my home server so that I could use the domains on my internal network.