.. _installation-creating-the-app:

Creating the Symfony Application

Building your own Framework with the MicroKernelTrait

A:ref:`traditional Symfony app<installation-creating-the-app>` contains a sensible

directory structure, various configuration files and an ``AppKernel`` with several

bundles already-registered. This is a fully-featured app that's ready to go.

But did you know, you can create a fully-functional Symfony application in as little

as one file? This is possible thanks to the new

:class:`Symfony\\Bundle\\FrameworkBundle\\Kernel\\MicroKernelTrait`. This allows

you to start with a tiny application, and then add features and structure as you

need to.

..note::

The MicroKernelTrait requires PHP 5.4. However, there's nothing special about

this trait. If you're using PHP 5.3, simply copy its methods into *your* kernel

class to get the same functionality.

A Single-File Symfony Application

Start with a completely empty directory. Get ``symfony/symfony`` as a dependency

via Composer:

..code-block::bash

Next, create an ``index.php`` file that creates a kernel class and executes it::

That's it! To test it, you can start the built-in web server:

..code-block::bash

Then see the JSON response in your browser:

> http://localhost:8000/random/10

The Methods of a "Micro" Kernel

When you use the ``MicroKernelTrait``, your kernel needs to have exactly three methods

that define your bundles, your services and your routes:

**registerBundles()**

This is the same ``registerBundles()`` that you see in a normal kernel.

**configureContainer(ContainerBuilder $c, LoaderInterface $loader)**

This methods builds and configures the container. In practice, you will use

``loadFromExtension`` to configure different bundles (this is the equivalent

of what you see in a normal ``config.yml`` file). You can also register services

directly in PHP or load external configuration files (shown below).

**configureRoutes(RouteCollectionBuilder $routes)**

Your job in this method is to add routes to the application. The ``RouteCollectionBuilder``

is new in Symfony 2.8 and has methods that make adding routes in PHP more fun.

You can also load external routing files (shown below).

Advanced Example: Twig, Annotations and the Web Debug Toolbar

The purpose of the ``MicroKernelTrait`` is *not* to have a single-file application.

Instead, its goal to give you the power to choose your bundles and structure.

First, you'll probably want to put your PHP classes in an ``src/`` directory. Configure

your ``composer.json`` file to load from there:

..code-block::json

Now, suppose you want to use Twig and load routes via annotations. For annotation

routing, you need SensioFrameworkExtraBundle. This comes with a normal Symfony project.

But in this case, you need to download it:

..code-block::bash

Instead of putting *everything* in ``index.php``, create a new ``app/AppKernel.php``

to hold the kernel. Now it looks like this::

Unlike the previous kernel, this loads an external ``app/config/config.yml`` file,

because the configuration started to get bigger:

..configuration-block::

..code-block::yaml

..code-block::xml

..code-block::php

This also loads annotation routes from an ``src/App/Controller/`` directory, which

has one file in it::

Template files should live in the ``Resources/views`` directory of whatever directory

your *kernel* lives in. Since ``AppKernel`` lives in ``app/``, this template lives

at ``app/Resources/views/micro/random.html.twig``.

Finally, you need a front controller to boot and run the application. Create a

``web/index.php``:

// web/index.php

use Symfony\Component\HttpFoundation\Request;

require __DIR__.'/../app/AppKernel.php';

$kernel = new AppKernel('dev', true);

$request = Request::createFromGlobals();

$response = $kernel->handle($request);

$response->send();

$kernel->terminate($request, $response);

That's it! This ``/random/10`` URL will work, Twig will render, and you'll even

get the web debug toolbar to show up at the bottom. The final structure looks like

this:

..code-block::text

Hey, that looks a lot like a *traditional* Symfony application! You're right: the

``MicroKernelTrait`` *is* still Symfony: but you can control your structure and

features quite easily.

* :doc:`/cookbook/configuration/index`

* :doc:`/cookbook/configuration/environments`

* :doc:`/cookbook/configuration/micro-kernel-trait`

* :doc:`/cookbook/configuration/override_dir_structure`

* :doc:`/cookbook/configuration/using_parameters_in_dic`

* :doc:`/cookbook/configuration/front_controllers_and_kernel`