Another way to install the Laminas MVC Skeleton Application is to use github to download a compressed archive. Go to https://github.com/laminas/laminas-mvc-skeleton, click the "Clone or download" button, and select "Download ZIP". This will download a file with a name like laminas-mvc-skeleton-master.zip or similar.

Unzip this file into the directory where you keep all your vhosts and rename the resultant directory to laminas-mvc-tutorial.

laminas-mvc-skeleton is set up to use Composer to resolve its dependencies. Run the following from within your new laminas-mvc-tutorial folder to install them:

$ composer self-update
$ composer install

This takes a while. You should see output like the following:

Installing dependencies from lock file
- Installing laminas/laminas-component-installer (2.1.2)

...

Generating autoload files

At this point, you will be prompted to answer questions as noted above.

Alternately, if you do not have Composer installed, but do have docker-compose available, you can run Composer via those:

$ docker-compose build
$ docker-compose run laminas composer install

If you see this message:

[RuntimeException]
  The process timed out.

then your connection was too slow to download the entire package in time, and composer timed out. To avoid this, instead of running:

$ composer install

run instead:

$ COMPOSER_PROCESS_TIMEOUT=5000 composer install

For windows users with wamp:

1. Install Composer for Windows

Check Composer is properly installed by running:

$ composer

Otherwise follow the installation guide for Composer.

2. Install Git for Windows

Check Git is properly installed by running:

$ git

Otherwise follow the installation guide for GitHub Desktop.

3. Now Install the Skeleton Using

$ composer create-project -s dev laminas/laminas-mvc-skeleton path/to/install

Docker containers wrap a piece of software and everything needed to run it, guaranteeing consistent operation regardless of the host environment; it is an alternative to virtual machines, as it runs as a layer on top of the host environment.

docker-compose is a tool for automating configuration of containers and composing dependencies between them, such as volume storage, networking, etc.

The skeleton application ships with a Dockerfile and configuration for docker-compose; we recommend using docker-compose, as it provides a foundation for mapping additional containers you might need as part of your application, including a database server, cache servers, and more. To build and start the image, use:

$ docker-compose up -d --build

After the first build, you can truncate this to:

$ docker-compose up -d

Once built, you can also run commands on the container. The docker-compose configuration initially only defines one container, with the environment name "laminas"; use that to execute commands, such as updating dependencies via composer:

$ docker-compose run laminas composer update

The configuration includes both PHP 8.3 and Apache 2.4, and maps the host port 8080 to port 80 of the container.

We will not cover installing Apache, and will assume you already have it installed. We recommend installing Apache 2.4, and will only cover configuration for that version.

You now need to create an Apache virtual host for the application and edit your hosts file so that http://laminas-mvc-tutorial.localhost will serve index.php from the laminas-mvc-tutorial/public/ directory.

Setting up the virtual host is usually done within httpd.conf or extra/httpd-vhosts.conf. If you are using httpd-vhosts.conf, ensure that this file is included by your main httpd.conf file. Some Linux distributions (ex: Ubuntu) package Apache so that configuration files are stored in /etc/apache2 and create one file per virtual host inside folder /etc/apache2/sites-enabled. In this case, you would place the virtual host block below into the file /etc/apache2/sites-enabled/laminas-mvc-tutorial.

Ensure that NameVirtualHost is defined and set to *:80 or similar, and then define a virtual host along these lines:

<VirtualHost *:80>
    ServerName laminas-mvc-tutorial.localhost
    DocumentRoot /path/to/laminas-mvc-tutorial/public
    SetEnv APPLICATION_ENV "development"
    <Directory /path/to/laminas-mvc-tutorial/public>
        DirectoryIndex index.php
        AllowOverride All
        Require all granted
    </Directory>
</VirtualHost>

Make sure that you update your /etc/hosts or c:\windows\system32\drivers\etc\hosts file so that laminas-mvc-tutorial.localhost is mapped to 127.0.0.1. The website can then be accessed using http://laminas-mvc-tutorial.localhost.

127.0.0.1 laminas-mvc-tutorial.localhost localhost

Restart Apache.

If you've done so correctly, you will get the same results as covered under the PHP built-in web server.

To test that your .htaccess file is working, navigate to http://laminas-mvc-tutorial.localhost/1234, and you should see the 404 page as noted earlier. If you see a standard Apache 404 error, then you need to fix your .htaccess usage before continuing.

If you're are using IIS with the URL Rewrite Module, import the following:

RewriteCond %{REQUEST_FILENAME} !-f
RewriteRule ^ index.php [NC,L]

Error Reporting

Optionally, when using Apache, you can use the APPLICATION_ENV setting in your VirtualHost to let PHP output all its errors to the browser. This can be useful during the development of your application.

Edit laminas-mvc-tutorial/public/index.php directory and change it to the following:

use Laminas\Mvc\Application;
use Laminas\Stdlib\ArrayUtils;

/**
 * Display all errors when APPLICATION_ENV is development.
 */
if ($_SERVER['APPLICATION_ENV'] === 'development') {
    error_reporting(E_ALL);
    ini_set("display_errors", '1');
}

/**
 * This makes our life easier when dealing with paths. Everything is relative
 * to the application root now.
 */
chdir(dirname(__DIR__));

// Decline static file requests back to the PHP built-in webserver
if (php_sapi_name() === 'cli-server') {
    $path = realpath(__DIR__ . parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH));
    if (__FILE__ !== $path && is_file($path)) {
        return false;
    }
    unset($path);
}

// Composer autoloading
include __DIR__ . '/../vendor/autoload.php';

if (! class_exists(Application::class)) {
    throw new RuntimeException(
        "Unable to load application.\n"
        . "- Type `composer install` if you are developing locally.\n"
        . "- Type `docker-compose run laminas composer install` if you are using Docker.\n"
    );
}

// Retrieve configuration
$appConfig = require __DIR__ . '/../config/application.config.php';
if (file_exists(__DIR__ . '/../config/development.config.php')) {
    $appConfig = ArrayUtils::merge($appConfig, require __DIR__ . '/../config/development.config.php');
}

// Run the application!
Application::init($appConfig)->run();