DEV Community: Esnare Maussa

Using Lando with Drupal 9

Esnare Maussa — Mon, 07 Sep 2020 08:01:18 +0000

After years of working with MAMP, I decided to move my development stack to Docker and Docker Compose. I did it mainly out of curiosity as many of my colleagues were getting very excited with it.

And there I went, I started to dive deep into Docker compose, I learnt how to create my own docker files, use Dockerhub and started to master the syntax from Docker Compose. Nevertheless, it seemed to me that I had to do so much boiler to spin up a workable Drupal site.

One day, while browsing on the web, I found Lando!

Lando, - as they put it from their website - it's a free and open-source local development environment built on Docker container technology. Just by running on command: lando start, you are able to run a fully LAMP-based infrastructure regardless of what OS you're using.

$ lando start

Lando is not only for Drupal but it also gives you a pool of frameworks to choose from. Very effortless, you are able to run Drupal, Laravel, WordPress and many more.

Installation

Just head out to their installation page, they couldn't make it easier:
https://docs.lando.dev/basics/installation.html

Drupal 9 Configuiration

After installing Lando locally, you can run lando init, that command will help you to configure your site step by step.

$ lando init

At the end of the process, you should end up having a .lando.yml file, similar to the one below:

#.lando.yml
name: my-project
recipe: drupal9
config:
  webroot: web
  php: "7.4"

You can achieve the same by copying and pasting the code above into a .lando.yml file inside of your root directory and then just run lando start

Running Drush

You can run Drush commands by prefixing lando at the beginning of the command, such as lando drush command

#Example
$ lando drush cr

You won't have to worry about the Drush configuration anymore, Lando will take care that you are using the right PHP version and the right Drush version for your Drupal site.

More info about lando

Here are some interesting links about Lando:
Debugging Drupal 9 with Xdebug and (VSCode || PHPStorm)

Lando Overview

Lando Drupal9 recipe

Tooling with Lando

Debugging Drupal 9 with Xdebug and (VSCode || PHPStorm)

Esnare Maussa — Sun, 06 Sep 2020 06:09:23 +0000

In the old days, debugging Drupal websites consisted of printing out an array variable and inspect its values within. However, today with a more complex Drupal codebase, those days are gone and ... behold Xdebug

Xdebug emerged as a nicer tool for debugging Drupal 9 sites when developing modules or themes. Therefore, In this post will be configuring Xdebug with Lando and integrating with VSCode as well as PHPStorm.

Drupal 9 configuration

Let's start with the Drupal 9 configuration, we will be using the Composer drupal/recommended-project.

Thus we will spin off a new Drupal 9 site like so:

$ composer create-project drupal/recommended-project my_site_name_dir

Composer will take care of the third-party dependencies and downloading Drupal core files, just change the my_site_name_dir for the name of your project.

Lando configuration

We will be using the drupal9 recipe for lando which already come with a LAMP-based system for running Drupal 9 sites. This recipe is using PHP 7.3 per default. However, we will be running PHP 7.4 so we can use the latest version from the time of writing this post.

Here is my Lando (.lando.yml) file:

name: laboratory
recipe: drupal9
config:
  webroot: web
  php: 7.4
  xdebug: true
  config:
    php: ./php.ini

Here is a Gist for .lando.yml file: esnaremaussa/.lando.yml

xdebug: true

With this option, Lando will include Xdebug in the Docker container.

php: ./php.ini

This option will allow us to tell Lando to use our own php.ini configuration rather than using the default php.ini file.

php.ini configuration

This is the php.ini you should include in your project:

; Xdebug
xdebug.max_nesting_level = 256
xdebug.show_exception_trace = 0
xdebug.collect_params = 0
xdebug.remote_enable = 1
xdebug.remote_autostart = 1
xdebug.remote_host = ${LANDO_HOST_IP}
xdebug.remote_log = ./xdebug.log
xdebug.remote_port = 9000

This is a Gist for the php.ini file esnaremaussa/php.ini

This is a very generic configuration for Xdebug and everything should work out of the box after running lando start. Nevertheless, these two configuration items are very important, especially when experiencing problems with Xdebug:

xdebug.remote_port = 9000

Xdebug will be listening on port 9000 per default. Nevertheless, if you run into issues with Xdebug, don't' hesitate to change the port to 9001 (or anything, really) and rebuild lando.

xdebug.remote_log = ./xdebug.log

The xdebug.remote_log flag is used for defining the location of the Xdebug logs. Very handy when things don't work as expected.

The name can be anything and be located anywhere within your working directory. Right now, as configured above, the xdebug.log file will be located at the root of the application.

Trust me, changing the port when experiencing problems with Xdebug may just fix all your problems and save you a lot of time wandering around.

Wrapping up (first part)

Up to this point, you should be able to run lando start and have a Drupal 9 site up and running with Xdebug listening on port 9000.

For the second part, we will be configuring the most popular IDEs among PHP developers, VSCode and PHPStorm.

Xdebug and VSCode

Configuring VSCode with Xdebug is very simple, all you have to do is following these steps:

Make sure have installed the PHP Debug plugin.
This plugin can be found here: PHP Debug.
Create the folder .vscode in the root of your application and create the launch.json file with the following code:

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Listen for XDebug",
      "type": "php",
      "request": "launch",
      "port": 9000,
      "log": true,
      "pathMappings": {
        "/app/": "${workspaceFolder}/"
      }
    }
  ]
}

Note: in the port section, make sure is the same port added in the php.ini file.
This is a Gist for the launch.json file esnaremaussa/launch.json

Create breakpoints on your code.
For testing purposes, you can go to the index.php file and add $test = 1 and add that line as a breakpoint in VSCode.
Go to the debugger section on VSCode and run the option which says: Listen for XDebug.
Finally, go to your Lando site and refresh your browser.

You should end up seeing something like this:

NOTE: On the Breakpoint section (bottom left in the image above), Everything is marked as default. You should uncheck all the breakpoints selected per default and only leave the ones you have marked in your code.
For some reason, the default breakpoints do not work with Drupal.

PHP Storm and Xdebug

Let's breakdown the PHPStorm configuration is a series of steps:

Open the configuration window.
You can get there by clicking on: configuration -> Languages and Frameworks -> PHP
On PHP language level, we tell PHPStorm that we will be using PHP 7.4
Let's configure the CLI Interpreter.

NOTE: You will have to tell to PHPStorm the path of the Xdebug.so file, you can get that by running these commands:
$ lando ssh
$ cat /usr/local/etc/php/conf.d/docker-php-ext-xdebug.ini

Now, create some breakpoints and start listening for Xdebug connections.
Refresh your browser and the debugger will show up with the index.php variables.

Up to this point, you should have a functional PHPStorm + Xdebug configuration. Nevertheless, there is more to it, you can have Drush, PHP Unit and more integrations with PHPStorm.

I will add a couple of links at the end of the post where there will be more info about

Have fun and debug away!

More Resources

https://docs.lando.dev/guides/lando-phpstorm.html
https://docs.lando.dev/guides/lando-with-vscode.html
https://untoldhq.com/blog/2019/08/02/when-lando-phpstorm-and-xdebug-setup-gets-hairy

Single sign-on with Simplesamlphp and Drupal 9

Esnare Maussa — Mon, 20 Jul 2020 07:04:01 +0000

Authentication is one of the most common features in any web development project. Therefore, Drupal, as one of the most popular CMS out there, has their own implementation and opinions about how authentication should be implemented.

However, what happens when there are multiple sites under the same domain/subdomain and there is the need for one single login for all them, Do you have to tell your users to create multiple user accounts on each app/website?

What if the app stack is made with different frameworks or there are other projects linked to your app/website, Does that mean the dev team will have to deal with their own opinionated authentication process as well?

If you are asking yourself those questions, the answer may be that you need a single sign-on service for your applications.

There are many services out which will give you all the tools you need to have one single login across all your application stack. Nevertheless, this blog post will focus on describing how to have one single login between two Drupal sites using the SAML open standard.

Here is our stack

Drupal 9 websites

We will need two Drupal 9 websites, the Identity Provider or IdP and the Service Provider or SP.

These Drupal sites will be built with the composer Recommended Project from Drupal:



composer create-project drupal/recommended-project my_site_name_dir

More about Drupal and Composer here: https://www.drupal.org/docs/develop/using-composer/using-composer-to-install-drupal-and-manage-dependencies

Lando

This is a great project that uses Docker for creating containers with all the necessary services to run any Drupal application.

The great thing about Lando and/or Docker is that help us with a dev stack for stateless applications. In other words, we will be able to spin off new versions of the site very easily without having to configure or making complex changes in our OS.

Lando documentation for Drupal

Simplesamlphp

This is the star of the show!
Simplesamlphp is a PHP library that implements the SAML (Security Assertion Markup Language) open standard.

We will be looking into more details further down the road, but for now, implementing this library will give us that single login for all the applications in our stack.

Checkout the documentation here

Last but not least

We will be also using these two fantastic projects:

Drupalauth: This is a module for the Simplesaml library which will connect Simplesaml with the Drupal user table.
DrupalAuth for SimpleSAMLphp: This is a Drupal module which will handle the connection between Drupal and Simplesaml.

What does IDP and SP even mean?

These two concepts are the key components in a SMAL authentication process.

Identity provider

A SAML identity provider is a system entity that issues authentication assertions in conjunction with a single sign-on (SSO) profile of the Security Assertion Markup Language (SAML).

In the SAML domain model, a SAML authority is any system entity that issues SAML assertions.[OS 1] Two important examples of SAML authorities are the authentication authority and the attribute authority.

Extracted from: wikipedia.org

Service provider

A SAML service provider is a system entity that receives and accepts authentication assertions in conjunction with a single sign-on (SSO) profile of the Security Assertion Markup Language (SAML).

In the SAML domain model, a SAML relying party is any system entity that receives and accepts information from another system entity.[OS 1] Of particular interest is a SAML relying party that receives and accepts a SAML assertion issued by a SAML authority.

Extracted from: wikipedia.org

What does that mean for our project?

In our stack, the IdP will be our main Drupal site where all the usernames and passwords will be stored. In other words, think of this site as the master site where all the other apps will be connected to in other to login.

On the other hand, we have the SP, another Drupal 9 site, this site won't store any user data and, when users click on login, their login credentials (username and password) will be verified against the IdP.

Enough theory, let's do this

I have created two GitHub repositories one for the IDP and another for the SP:

The IDP
https://github.com/esnaremaussa/drupal9-idp
The SP
https://github.com/esnaremaussa/drupal9-sp

Those repositories already include a .lando.yml file. Therefore, running lando start will spin off the Docker containers with the LAMP stack and any other fancy configuration for Drupal.

You will end up with two sites:

NOTE: We will use Lando throughout this blog post, so I recommend to install it if you want to follow along.

Configuring the IdP website

It's the moment for the drupalauth and DrupalAuth for SimpleSAMLphp projects to shine.

As per the Drupalauth project documentation, there are two ways to do this:

We will be working with the 2nd option.

Installing the Simplesamlphp library

We will run the following command on the terminal:



# Downloding the drupalauth4ssp module
$ lando composer require drupal/drupalauth4ssp
# Installing the drupalauth4ssp module
$ lando drush en drupalauth4ssp -y

With the above command, Composer will download all the third-party libraries we need for this project. Let me explain, the Drupalauth4ssp module has listed the Simplesamlphp library as well as Drupalauth module as a dependency. Therefore, when Composer is downloading the Drupalauth4ssp, it will also download all the libraries we require to get Simplesaml working on our project.

On top of that, Composer will take care of versioning. In other words, it will make sure that the right versions are downloaded for this project.

You got to love composer!

In order to double-check that everything was installed correctly, go to your vendor folder and look for the simplesamlphp project, then check inside the modules folder, the Drupalauth module should be there too.



# Check if the simplesamlphp library is installed
ls -lha vendor/simplesamlphp/simplesamlphp
# Check if the Drupalauth module is installed
ls -lha vendor/simplesamlphp/simplesamlphp/modules/drupalauth

Configuring the simplesamlphp library

At the moment, the Simplesamlphp library is downloaded but we can't access it from the browser. The reason being, Drupal only allows specific folders to be accessible by Apache/Nginx. Let's fix this by creating a symlink from the www folder, inside the simplesamlphp folder, to the web folder.



# Connect inside the appserver container
lando ssh
# Create the symlink
ln -nfs /app/vendor/simplesamlphp/simplesamlphp/www web/simplesaml

.htaccess configuration

All directories on Drupal are protected by a configuration on the .htaccess file. Therefore, we need to whitelist Simplesmal directories so we can see it on the browser.

Just after this line:



RewriteCond %{REQUEST_URI} !/core/modules/statistics/statistics.php$

Add the code:



  # Allow access to simplesamlphp scripts.
  RewriteCond %{REQUEST_URI} !/simplesaml/[^/]*\.php$
  RewriteCond %{REQUEST_URI} !/simplesaml/admin/[^/]*\.php$
  RewriteCond %{REQUEST_URI} !/simplesaml/[^/]*\.php/sanitycheck/[^/]*\.php$
  RewriteCond %{REQUEST_URI} !/simplesaml/[^/]*\.php/drupalauth/[^/]*\.php$
  RewriteCond %{REQUEST_URI} !/simplesaml/[^/]*\.php/core/idp/[^/]*\.php$
  RewriteCond %{REQUEST_URI} !/simplesaml/[^/]*\.php/saml/[^/]*\.php$
  RewriteCond %{REQUEST_URI} !/simplesaml/saml2/idp/[^/]*\.php$
  RewriteCond %{REQUEST_URI} !/simplesaml/saml2/idp/[^/]*\.php/drupal-userpass$
  RewriteCond %{REQUEST_URI} !/simplesaml/[^/]*\.php/saml/sp/[^/]*\.php/default-sp$

Although You should be able to access the Simplesaml from the browser now, you may be facing an error. This issues will be solved in the next step.

IMPORTANT: From simplicity, I will be modifying configuration files from the vendor folder. However, this is not recommended and I will encourage you to look for the best way to persist the data for your configuration and deployment process.

Config Files and Metadata

Currently, the IdP website is displaying some errors when accessing the simplesaml library at https://idp.lndo.site/simplesaml/

Let's fix this by copy the configuration files from the config-templates to the config folder:



cp -r vendor/simplesamlphp/simplesamlphp/config-templates/* vendor/simplesamlphp/simplesamlphp/config

And let's the same for the metadata files



cp -r vendor/simplesamlphp/simplesamlphp/metadata-templates/* vendor/simplesamlphp/simplesamlphp/metadata

Now, let's dive deep into the Simplesamlphp configuration.

look for the config.php file inside the config folder and do the following changes:



 'secretsalt' => 'RANDOM-NUMBER',

Running this command on the terminal will give you a random number for the secret salt:



LC_CTYPE=C tr -c -d '0123456789abcdefghijklmnopqrstuvwxyz' </dev/urandom | dd bs=32 count=1 2>/dev/null;echo

Master password for the Simplesamlphp backend:



 'auth.adminpassword' => 'MySuperStrongPassword',

You can use the story type you'd like, for this example, we will use MySQL:



 'store.type' => 'sql' 
 'store.sql.dsn' => 'mysql:host=database;dbname=drupal9',
 'store.sql.username' => 'drupal9',
 'store.sql.password' => 'drupal9',

Enable the IdP mode:



 'enable.saml20-idp' => true,

Finally, add this line add the end of the config.php file:



 $config['baseurlpath'] = 'https://'. $_SERVER['HTTP_HOST'] . '/simplesaml/';

Certificates

Simplesaml requires certificates to be generate on the server for more security. A new cert folder will have to be created and generate the certificates there:



# Connect inside the appserver container
$ lando ssh
# Create cert folder
$ mkdir -p vendor/simplesamlphp/simplesamlphp/cert
# Go to the cert folder
$ cd vendor/simplesamlphp/simplesamlphp/cert
# Generate certificates
$ openssl req -newkey rsa:3072 -new -x509 -days 3652 -nodes -out server.crt -keyout server.pem

simplesamlphp-module-drupalauth configuration

The Drupalauth project is a Simplesamlphp module which connects Simplesamlphp with the IdP website. In addition, it maps the Drupal user credentials in a way that Simplesamlphp can understand.

NOTE: As stated at the beginning, we will be configuring the IdP site so it Authenticates against Drupal but use the Drupal login page.

In the configuration folder, look for the **authsources.php file, then copy and paste the following code:



 'drupal-userpass' => [
        'drupalauth:External',
        // The filesystem path of the Drupal directory.
        'drupalroot' => '/app/web/',
        // Whether to turn on debug
        'debug' => true,
        // the URL of the Drupal logout page
        'drupal_logout_url' => 'https://idp.lndo.site/user/logout',
        // the URL of the Drupal login page
        'drupal_login_url' => 'https://idp.lndo.site/user/login',
        // Which attributes should be retrieved from the Drupal site.
        'attributes' => array(
            array('field_name' => 'uid', 'attribute_name' => 'uid'),
            array('field_name' => 'roles', 'attribute_name' => 'roles', 'field_property' => 'target_id'),
            array('field_name' => 'name', 'attribute_name' => 'cn'),
            array('field_name' => 'mail', 'attribute_name' => 'mail'),
            array('field_name' => 'field_first_name', 'attribute_name' => 'givenName'),
            array('field_name' => 'field_last_name', 'attribute_name' => 'sn'),
            array('field_name' => 'field_organization', 'attribute_name' => 'ou', 'field_property' => 'target_id'),
        ),
    ],

Metadata configuration

For this section, we will be modifying the files inside the metadata folder:



ls vendor/simplesamlphp/simplesamlphp/metadata

At the moment, we just need to locate the saml20-idp-hosted.php and the drupal-userpass value on the auth key.



'auth' => 'drupal-userpass',

There will more metadata we need to configure but let's create the SP website first.

Testing your work so far
There is a very simple way to know if you have done the steps above properly. First, go to the Simplesamlphp backend, https://idp.lndo.site/simplesaml. Then, go to the Test authentication sources section. Finally, click on the drupal-userpass option listed there.

After you click it, you should be taken to the Drupal login page. That means you're on track! ;)

Configuring the Service Provider (SP)

Let's move on now and create a consumer website. We'll be using the https://github.com/esnaremaussa/drupal9-sp repository to build this project.

Run lando start and you should be running your site at https://sp.lndo.site

Next, download and install simpleSAMLphp Authentication module from Drupal.



# Download the simplesamlphp_auth Authentication module
$ lando composer require drupal/simplesamlphp_auth 
# Install the simplesamlphp_auth Authentication module
$ lando drush en simplesamlphp_auth -y

The simplesamlphp_auth has the Simplesamlphp library as a dependency. Therefore, you should be able to find it in your vendor folder after running the composer install command.

Configuring the simplesamlphp_auth module

This module is very flexible and offers a good set of configuration for your Drupal site. However, the module is disabled by default.

For this example, we will make minimal changes to this module. Thus, go to the User info and syncing tab and add the value uid for the following fields:

SimpleSAMLphp attribute to be used as unique identifier for the user.
SimpleSAMLphp attribute to be used as username for the user.

Configuring the Simplesamlphp library for the SP

The Simplesamlphp library is a dependency for the simplesamlphp_auth module. Therefore, it should be downloaded in the vendor folder.



# Check if the simplesamlphp library is installed
$ ls -lha vendor/simplesamlphp/simplesamlphp

The configuration steps for the SP are pretty much the same as the IdP. Thus here is a quick summary of the commands for configuring the Simplesamlphp library:



# SSH the appserver container
lando ssh
# Create the symlink
ln -nfs /app/vendor/simplesamlphp/simplesamlphp/www web/simplesaml

.httaccess configuration
Just after this line:



RewriteCond %{REQUEST_URI} !/core/modules/statistics/statistics.php$

Add the code:



  # Allow access to simplesamlphp scripts.
  RewriteCond %{REQUEST_URI} !/simplesaml/[^/]*\.php$
  RewriteCond %{REQUEST_URI} !/simplesaml/admin/[^/]*\.php$
  RewriteCond %{REQUEST_URI} !/simplesaml/[^/]*\.php/sanitycheck/[^/]*\.php$
  RewriteCond %{REQUEST_URI} !/simplesaml/[^/]*\.php/drupalauth/[^/]*\.php$
  RewriteCond %{REQUEST_URI} !/simplesaml/[^/]*\.php/core/idp/[^/]*\.php$
  RewriteCond %{REQUEST_URI} !/simplesaml/[^/]*\.php/saml/[^/]*\.php$
  RewriteCond %{REQUEST_URI} !/simplesaml/saml2/idp/[^/]*\.php$
  RewriteCond %{REQUEST_URI} !/simplesaml/saml2/idp/[^/]*\.php/drupal-userpass$
  RewriteCond %{REQUEST_URI} !/simplesaml/[^/]*\.php/saml/sp/[^/]*\.php/default-sp$

Config Files and Metadata

Add the code:



# Copy configuration template files
cp -r vendor/simplesamlphp/simplesamlphp/config-templates/* vendor/simplesamlphp/simplesamlphp/config
# Copy metadata template files
cp -r vendor/simplesamlphp/simplesamlphp/metadata-templates/* vendor/simplesamlphp/simplesamlphp/metadata

Making changes on the config.php file



'secretsalt' => 'RANDOM-NUMBER',

'auth.adminpassword' => 'MySuperStrongPassword',

'store.type' => 'sql' 
'store.sql.dsn' => 'mysql:host=database;dbname=drupal9',
'store.sql.username' => 'drupal9',
'store.sql.password' => 'drupal9',

#Finally, add this line at the end of the config.php file:
$config['baseurlpath'] = 'https://'. $_SERVER['HTTP_HOST'] . '/simplesaml/';

Making changes on the authsources.php file
For the SP, we will use the default-sp authentication source.

Checkout the code snipped:



'idp' => 'https://idp.lndo.site/simplesaml/saml2/idp/metadata.php',

Certificates



# SSH the appserver container
$ lando ssh
# Create cert folder
$ mkdir -p vendor/simplesamlphp/simplesamlphp/cert
# Go to the cert folder
$ cd vendor/simplesamlphp/simplesamlphp/cert
# Generate certificates
$ openssl req -newkey rsa:3072 -new -x509 -days 3652 -nodes -out server.crt -keyout server.pem

Metadata SP configuration
Open the file saml20-idp-hosted.php, inside the metadata folder and add the following code:



'auth' => 'drupal-userpass',

Exchanging Metadata between the SP and Idp

This is the final step!

Let's add the SP metadata on the IdP
On your SP Simplesaml website, go to the Federation tab, look for the SAML 2.0 SP Metadata section and click on show metadata.

You should copy the PHP array on the metadata section.

If you have been following along, this should be SP metadata URL: https://sp.lndo.site/simplesaml/module.php/saml/sp/metadata.php/default-sp?output=xhtml

Then, go to your IdP codebase, look for the metadata folder and locate the saml20-sp-remote.php file, at the end of that file you should paste the PHP array.



# This is an example of the first lines of the metadata array.
$metadata['https://sp.lndo.site/simplesaml/module.php/saml/sp/metadata.php/default-sp'] = array (
  'SingleLogoutService' => 
  array (
    0 => 
    array (
      'Binding' => 'urn:oasis:names:tc:SAML:2.0:bindings:HTTP-Redirect',
      'Location' => 'https://sp.lndo.site/simplesaml/module.php/saml/sp/saml2-logout.php/default-sp',
    ),
.
.
.

Let's add the IdP metadata on the SP
On your IdP Simplesaml website, go to the Federation tab, look for the SAML 2.0 IdP Metadata section and click on show metadata.

If you have been following along, this should be IdP metadata URL: https://idp.lndo.site/simplesaml/saml2/idp/metadata.php?output=xhtml

Then, go to your SP codebase, look for the metadata folder and locate the saml20-idp-remote.php file, at the end of that file you should paste the PHP array.



# This is an example of the first lines of the metadata array.

$metadata['https://idp.lndo.site/simplesaml/saml2/idp/metadata.php'] = array (

  'metadata-set' => 'saml20-idp-remote',

  'entityid' => 'https://idp.lndo.site/simplesaml/saml2/idp/metadata.php',

  'SingleSignOnService' => 

.

.

.

Known issues

Currently, there is just one issue with the Drupalauth Simplesamlphp module. The Crypt::hashEquals function is deprecated for Drupal 9 and the hash_equals from PHP should be used instead.

Have a look here: https://github.com/drupalauth/simplesamlphp-module-drupalauth/issues/62

Wrapping Up

And there you are!
You should have now the Simplesamlphp library up and running on both SP and IdP sites. Also, you should be able to authenticate on the SP with the users registered on the IdP.

Statesless version
Lando not only provides the option of spin-off environments for Drupal development. It also allows to run configuration code before/after the services are up and running. This is possible because Lando is a superset of Docker and you should be able to do the same things that you normally do with Docker Compose.

In other words, all those commands needed for the Simplesamlphp library configuration can be added to the IdP and SP websites before the app services are running, just like a CI/CD system.

Go to any of these two projects:

There should be a branch called stateless. In that branch, all the configuration explained here will be done automatically just by running lando start.

Upgrading from Drupal 8 to Drupal 9 with Composer

Esnare Maussa — Thu, 25 Jun 2020 03:26:43 +0000

Drupal 9 is the new flagship of the popular Framework which was released on June 3, 2020 and it's ready to be used for Production sites.

Here are the main Drupal 9 features:

Symfony 4.4
Twig 2
CKEditor 4
PHPUnit out of the box.
Official composer template drupal/recommended-project.

And many other tools for developers to play with:

Drupal 8.9

Drupal 8.9 was released alongside with Drupal 9, this release includes the same features coming in Drupal 9 with the addition of having backward compatibility for public APIs.

This version is also the end of the Drupal 8 era as there won't be any more updates after this. Therefore, there won't be an 8.10 version coming anytime soon.

8.9 will be maintained until November 2021 and it's a great place to start the process of moving your current website to Drupal 9.

Upgrading to 8.9 will ensure maximum compatibility and the smallest necessary changes for the Drupal 9 update.

Drupal 9 and Composer

If you have been using composer to build your Drupal 8 website, you have been probably using drupal-composer/drupal-project.

Now Drupal 9 comes with an official template called drupal/recommended-project.

With this, you should be able to spin off new Drupal sites with the following command:

composer create-project drupal/recommended-project my-project

Let's start upgrading from D8 to D9

Before attempt to upgrade your site to Drupal 9, you should update your Drupal 8 to the 8.9 version.

As said before, Upgrading to 8.9 will ensure maximum compatibility and the smallest necessary changes for the Drupal 9 update.

Upgrade Status module

This is a module from the community that tells you what modules need to be updated/patch, what line is the issue and - most of the time - hot to fix it.

This a great module which works for custom and contrib projects.

https://www.drupal.org/project/upgrade_status

This is the step where you will probably spend most of the time as you will have to make sure your current Drupal 8 website is compatible with the Drupal codebase.

Upgrading to Drupal 9 (core) using Composer

Composer is the preferred way of moving forward to work with Drupal 9.

You will have to make sure all the libraries and modules installed on your current site are Drupal 9 compatible. Otherwise, you will get a lot of errors on the terminal thrown by Composer.

Run the following commands to get started with the process:

Remove the drupal/core entry in your composer.json file if you have it.
Change access permissions for the default folder and the files inside of it:

chmod 777 web/sites/default
find web/sites/default -name "*settings.php" -exec chmod 777 {} \;
find web/sites/default -name "*services.yml" -exec chmod 777 {} \;

Pull Drupal 9 and dev dependencies packages:

composer require drupal/core-recommended:^9.0.0 drupal/core-composer-scaffold:^9.0.0 drupal/core-project-message:^9.0.0 --update-with-dependencies --no-update
# If you have drupal/core-dev installed.
composer require drupal/core-dev:^9.0.0 --dev --update-with-dependencies --no-update

Update your local code:

composer update

Run database updates:

#Drush
drush updatedb

#Drupal console
drupal update:execute

Restoring default permissions:

chmod 755 web/sites/default
find web/sites/default -name "*settings.php" -exec chmod 644 {} \;
find web/sites/default -name "*services.yml" -exec chmod 644 {} \;

And voila! Check that your site is up and running, run your tests - if that is your thing - and any custom functionality you have on your site.

The above steps are coming from the Drupal Community
https://www.drupal.org/docs/upgrading-drupal/upgrading-from-drupal-8-to-drupal-9-or-higher

Final Thoughts

The Drupal community promised that upgrading to Drupal 9 will be easier than the previous versions and they hold their end of the bargain. Nevertheless, this is only true if:

Your website has been upgraded to each Drupal minor versions over the years.
All custom/contrib modules are Drupal 9 compatible.
Your custom/contrib themes are compatible with Twig 2.

Drupal 8 and Deployer.org

Esnare Maussa — Mon, 25 May 2020 10:31:55 +0000

Over the years, I have been getting obsessed with Deployment systems, especially for Drupal/Laravel sites which is what I mostly work with.

Drupal 8 is using composer now to pull the code from core and contrib modules making it easier the process of sending deployments to different environments.

However, all the deployment systems I was using were custom bash code built by myself or my colleagues and I wanted something that it was built in PHP, after all, these deployment processes will be moving code for PHP frameworks like Drupal 8 and Laravel. Therefore, I just wanted to be consistent with just one programing language.

Deployment automation has never been easier

Before we start, here are a few concepts you need to visit first:

Drupal composer template: https://github.com/drupal-composer/drupal-project
Atomic Deployments: https://buddy.works/blog/introducing-atomic-deployments

Deployer (https://deployer.org) is an atomic deployment tool built in PHP which supports deployments workflows for popular frameworks out of the box.

Deployer uses recipes to help you out with most of the boilerplate for the most popular frameworks out there.

We will be using Drupal 8 to show how to implement it.

Installation

This will install deployed in your local computer

curl -LO https://deployer.org/deployer.phar
mv deployer.phar /usr/local/bin/dep
chmod +x /usr/local/bin/dep

Getting Started

With the installation above, you should be able to run the "dep" command.
You could do something like:

dep init -t Drupal8

and create the basic boilerplate on your deploy.php file.

Setting up the deploy.php file

All the Deployer's logic will live in a file called deploy.php, I like to place it in my repository root so I can run Deployer commands directly from the root of my project.

Let's see the content of the deploy.php file

<?php
namespace Deployer;

require 'recipe/drupal8.php';

// You should add server folder where your application lives.
set('application', 'PATH TO YOUR SERVER FOLDER');

// Add the Git URL from your Project
// TIP: the destination server should have access to clone the repo
set('repository', 'GIT URL');

// Set up the Share files or Directory
// In this case, we are using the Drupal 8 recepie. Therefore, Deployer will add the Drupal Files folder as a default share folder. 
add('shared_files', []);
add('shared_dirs', []);

// MAX releases you want o keep on your server
set('keep_releases', 3);


// Hosts

host('IP ADDRESS DESTINATION SERVER')
    ->user('USER')
    ->port(22)
    ->identityFile('~/.ssh/id_rsa')
    ->set('deploy_path', '/{{application}}');

Defining tasks

Tasks are one of my Deployer's favourite features. With tasks, you can define instructions after or before one of the built-in Deployer tasks runs.
Here is an example: Before my deployment finish I need to make sure the new files are using the www-data user and group.

// Setting up a custom task called permissions:www-data
task('permissions:www-data', function () {
    run('chown -R www-data.www-data {{application}}');
});

// Then at the end of my deploy.php file we add:
before('deploy:symlink', 'permissions:www-data');

I added a couple more tasks as an example, so here is my final deploy.php file:

<?php
namespace Deployer;

require 'recipe/drupal8.php';

// You should add server folder where your application lives.
set('application', 'PATH TO YOUR SERVER FOLDER');

// Add the Git URL from your Project
// TIP: the destination server should have access to clone the repo
set('repository', 'GIT URL');

// Set up the Share files or Directory
// In this case, we are using the Drupal 8 recepie. Therefore, Deployer will add the Drupal Files folder as a default share folder. 
add('shared_files', []);
add('shared_dirs', []);

// MAX releases you want o keep on your server
set('keep_releases', 3);


// Hosts

host('IP ADDRESS DESTINATION SERVER')
    ->user('USER')
    ->port(22)
    ->identityFile('~/.ssh/id_rsa')
    ->set('deploy_path', '/{{application}}');

task('permissions:www-data', function () {
    run('chown -R www-data.www-data {{application}}');
});

task('permissions:www-data:current-folder', function () {
    run('chown -R www-data.www-data {{application}}/current');
});

before('deploy:symlink', 'permissions:www-data');
after('deploy:symlink', 'permissions:www-data:current-folder');

Well, I guess I have covered the basics here :)

Here is the docs in case you need more info: https://deployer.org/docs/getting-started.html