Macros in Apache Webserver

Simplify Your Apache Configuration with mod_macro

Managing an Apache webserver can sometimes be a daunting task, especially when dealing with repetitive configuration blocks. This is where mod_macro comes in handy. mod_macro is an Apache module that provides macros within Apache HTTPD runtime configuration files, making it easier to create numerous similar configuration blocks. 

What is mod_macro?

mod_macro allows you to define macros using <Macro> blocks, which contain the portion of your configuration that needs to be repeated. These macros can include variables for parts that will need to be substituted. When the server starts up, the macros are expanded using the provided parameters, and the result is processed along with the rest of the configuration file.

mod_macro can work with AEM as a Cloud Service (AEMaaCS) Dispatcher. The Dispatcher is an Apache HTTP Web server module that provides a security and performance layer between the CDN and AEM Publish tier. Since mod_macro is an Apache module, it can be used in conjunction with the Dispatcher to simplify and manage your Apache configurations

Uses of mod_macro

mod_macro can be used for various purposes, including:

1. Virtual Host Configuration: Define reusable virtual host configurations to simplify the setup of multiple similar virtual hosts.
2. Logging Configurations: Create macros for logging configurations to ensure consistency across different virtual hosts.
3. Directory Listings: Set up directory listings with custom options using macros.
4. Access Control: Define access control configurations that can be reused across multiple directories or locations.
5. Custom Error Pages: Create macros for custom error pages to handle different error codes consistently.

Installation on Mac

To install mod_macro on a Mac, follow these steps:

1. Install Apache: Ensure that Apache is installed on your Mac. You can use Homebrew to install Apache:

   brew install httpd

2. Install mod_macro : Use Homebrew to install the mod_macro module:

   brew install mod_macro

3. Enable mod_macro: Enable the module by adding the following line to your Apache configuration file (usually located at /usr/local/etc/httpd/httpd.conf):

   LoadModule macro_module /usr/local/Cellar/mod_macro/2.4.5/libexec/mod_macro.so

4. Restart Apache: Restart Apache to apply the changes:

   sudo apachectl restart

Installation on Windows

To install mod_macro on Windows, follow these steps:

1. Install Apache: Ensure that Apache is installed on your Windows machine. You can download and install Apache from the official Apache website.
2. Download modmacro: Download the modmacro module from the Apache website or a trusted source.
3. Place mod_macro in the Modules Directory: Copy the mod_macro.so file to the Apache modules directory (usually located at C:\Apache24\modules).
4. Enable modmacro: Open the Apache configuration file (usually located at C:\Apache24\conf\httpd.conf) and add the following line to enable modmacro:

   LoadModule macro_module modules/mod_macro.so

5. Restart Apache: Restart Apache to apply the changes:

   httpd -k restart

Examples

Alright! Here's a comprehensive list of 30 examples showcasing the flexibility and power of mod_macro in Apache webserver configurations:

---

Example 1: Virtual Host Configuration

Define a macro for a virtual host:

<Macro VHost $name $domain>
<VirtualHost *:80>
    ServerName $domain
    ServerAlias www.$domain
    DocumentRoot "/var/www/vhosts/$name"
    ErrorLog "/var/log/httpd/$name.error_log"
    CustomLog "/var/log/httpd/$name.access_log" combined
</VirtualHost>
</Macro>

Invoke the macro to create virtual hosts:

Use VHost example example.com
Use VHost myhost hostname.org
Use VHost apache apache.org

Example 2: Logging Configurations

Define a macro for logging configurations:

<Macro Logfiles $sitename>
CustomLog /var/log/apache2/$sitename-access.log combined
ErrorLog /var/log/apache2/$sitename-error.log
LogLevel warn
</Macro>

Invoke the macro to set up logging:

Use Logfiles example.com

Example 3: Directory Listings

Define a macro for directory listings:

<Macro DirList $dir>
<Directory $dir>
    Options +Indexes
    AllowOverride None
    Require all granted
</Directory>
</Macro>

Invoke the macro to enable directory listings:

Use DirList /var/www/html

Example 4: Access Control

Define a macro for access control:

<Macro AccessControl $dir>
<Directory $dir>
    AllowOverride None
    Order allow,deny
    Allow from all
</Directory>
</Macro>

Invoke the macro to set access control for directories:

Use AccessControl /var/www/private
Use AccessControl /var/www/public

Example 5: Custom Error Pages

Define a macro for custom error pages:

<Macro ErrorPage $code $file>
ErrorDocument $code $file
</Macro>

Invoke the macro to set custom error pages:

Use ErrorPage 404 /errors/404.html
Use ErrorPage 500 /errors/500.html

Example 6: Alias Directories

Define a macro for alias directories:

<Macro AliasDir $alias $path>
Alias $alias $path
<Directory $path>
    Options Indexes FollowSymLinks
    AllowOverride None
    Require all granted
</Directory>
</Macro>

Invoke the macro to create aliases:

Use AliasDir /images /var/www/images
Use AliasDir /files /var/www/files

Example 7: Proxy Configuration

Define a macro for proxy configurations:

<Macro ProxyConfig $proxyname $port>
<IfModule mod_proxy.c>
    ProxyRequests On
    <Proxy *>
        Order deny,allow
        Allow from all
    </Proxy>
    ProxyPass /$proxyname http://localhost:$port/
    ProxyPassReverse /$proxyname http://localhost:$port/
</IfModule>
</Macro>

Invoke the macro to set up proxy configurations:

Use ProxyConfig app1 8080
Use ProxyConfig app2 8090

Example 8: SSL Virtual Host

Define a macro for SSL virtual host:

<Macro SSLVHost $name $domain $cert $key>
<VirtualHost *:443>
    ServerName $domain
    ServerAlias www.$domain
    DocumentRoot "/var/www/vhosts/$name"
    SSLEngine on
    SSLCertificateFile $cert
    SSLCertificateKeyFile $key
    ErrorLog "/var/log/httpd/$name-ssl.error_log"
    CustomLog "/var/log/httpd/$name-ssl.access_log" combined
</VirtualHost>
</Macro>

Invoke the macro to create SSL virtual hosts:

Use SSLVHost secure1 secure1.com /etc/ssl/certs/secure1.crt /etc/ssl/private/secure1.key
Use SSLVHost secure2 secure2.com /etc/ssl/certs/secure2.crt /etc/ssl/private/secure2.key

Example 9: Rewrite Rules

Define a macro for rewrite rules:

<Macro RewriteRules $pattern $substitution>
RewriteEngine On
RewriteRule $pattern $substitution [L]
</Macro>

Invoke the macro to set up rewrite rules:

Use RewriteRules "^/oldpath(.*)$" "/newpath$1"
Use RewriteRules "^/blog(.*)$" "/articles$1"

Example 10: Directory Protection

Define a macro for directory protection:

<Macro ProtectDir $dir $userfile>
<Directory $dir>
    AuthType Basic
    AuthName "Restricted Area"
    AuthUserFile $userfile
    Require valid-user
</Directory>
</Macro>

Invoke the macro to protect directories:

Use ProtectDir /var/www/private /etc/apache2/.htpasswd
Use ProtectDir /var/www/secure /etc/apache2/.htpasswd

Example 11: Environment Variables

Define a macro for setting environment variables:

<Macro SetEnvVar $var $value>
SetEnv $var $value
</Macro>

Invoke the macro to set environment variables:

Use SetEnvVar APP_ENV production
Use SetEnvVar APP_DEBUG false

Example 12: MIME Types

Define a macro for adding MIME types:

<Macro AddMimeType $type $ext>
AddType $type $ext
</Macro>

Invoke the macro to add MIME types:

Use AddMimeType application/json .json
Use AddMimeType text/css .css

Example 13: Cache Control

Define a macro for cache control headers:

<Macro CacheControl $dir $cachetime>
<Directory $dir>
    ExpiresActive On
    ExpiresDefault "access plus $cachetime"
</Directory>
</Macro>

Invoke the macro to set cache control:

Use CacheControl /var/www/html 1 hour
Use CacheControl /var/www/images 1 week

Example 14: Security Headers

Define a macro for adding security headers:

<Macro SecurityHeaders>
Header always set X-Frame-Options "SAMEORIGIN"
Header always set X-Content-Type-Options "nosniff"
Header always set X-XSS-Protection "1; mode=block"
</Macro>

Invoke the macro to set security headers:

Use SecurityHeaders

Example 15: Compression

Define a macro for enabling compression:

<Macro Compression>
<IfModule mod_deflate.c>
    AddOutputFilterByType DEFLATE text/html text/plain text/xml
</IfModule>
</Macro>

Invoke the macro to enable compression:

Use Compression

Example 16: HTTP/2 Configuration

Define a macro for HTTP/2 configuration:

<Macro Http2Config>
<IfModule http2_module>
    Protocols h2 h2c http/1.1
    H2Push on
    H2Direct on
</IfModule>
</Macro>

Invoke the macro to set up HTTP/2:

Use Http2Config

Example 17: Rate Limiting

Define a macro for rate limiting:

<Macro RateLimit $path $rate>
<Location $path>
    SetOutputFilter RATE_LIMIT
    SetEnv rate-limit $rate
</Location>
</Macro>

Invoke the macro to set rate limiting:

Use RateLimit /api 10kb/s
Use RateLimit /downloads 50kb/s

Example 18: Static File Caching

Define a macro for static file caching:

<Macro StaticCache $path $cachetime>
<Location $path>
    Header set Cache-Control "max-age=$cachetime, public"
</Location>
</Macro>

Invoke the macro to set static file caching:

Use StaticCache /static 3600
Use StaticCache /assets 86400

Example 19: GZip Compression

Define a macro for GZip compression:

<Macro GZipCompression>
<IfModule mod_deflate.c>
    AddOutputFilterByType DEFLATE text/html text/plain text/xml application/json
</IfModule>
</Macro>

Invoke the macro to enable GZip compression:

Use GZipCompression

Example 20: Directory Security

Define a macro for directory security:

<Macro SecureDir $dir>
<Directory $dir>
    Options -Indexes
    AllowOverride None
    Require all denied
</Directory>
</Macro>

Invoke the macro to secure directories:

Use SecureDir /var/www/private
Use SecureDir /var/www/secret

Example 21: Custom Header

Define a macro for setting custom headers:

<Macro CustomHeader $header $value>
Header set $header $value
</Macro>

Invoke the macro to set custom headers:

Use CustomHeader X-Custom-Header "MyValue"
Use CustomHeader X-Powered-By "Apache"

Example 22: Maintenance Mode

Define a macro for maintenance mode: 

```apache <Macro MaintenanceMode $file>

<Location />

    ErrorDocument 503 $file

    RewriteEngine On

    Rewrite

Conclusion

mod_macro is a powerful tool that simplifies the management of Apache configurations by allowing you to define reusable macros. Whether you're managing multiple virtual hosts, complex logging configurations, or directory listings, mod_macro can help streamline your setup and make your life easier.