Decoupled Days 2019 will be held on July 17-18th at the John Jay College of Criminal Justice in New York City.
Decoupled Days is a conference for architects, developers and business people involved in implementing decoupled CMS architectures. This will be the third edition of the event.
Besides providing attendees the opportunity to connect with people sharing their interests, the conference aims to share best practices in decoupled, discuss difficult shared problems, and build open-source projects in ways that tangibly benefit their communities.
Axelerant is a Silver Sponsor at the event, and our team members have submitted several sessions. Here's a roundup of our session submissions:
Stand-up Bot: Using Decoupled Drupal to build An Asynchronous Stand-up Slack Bot
Team huddles or stand-ups in scrum keep the team informed and connected, and ensure that everyone is aware of the team’s current landscape and progress.
At Axelerant, we tried lots of existing Slack bots like Alice, Howdy, etc, but most of them had some limitations and we found minimal options to extend them. So, we built an asynchronous Slack bot to facilitate our stand-ups.
We will see how decoupled Drupal and GraphQL helped us provide a more customized stand-up bot catering to our needs, which, at the same time, is extensible and can let us add more features, like integrations with JIRA.
- Drupal offers the option to customize questionnaires for each team
- The bot will post questions to team members and remind them to answer
- The bot posts the summary of the stand-up in the Slack channel
- The bot can provide relevant actions to update on JIRA directly
In the session, we will talk about:
- Drupal 8 core services and GraphQL
- Building a bot for Slack
- How to extend and customize a bot for your needs, like creating surveys
API Design Strategy and Architecture
You might have been building and consuming APIs for some time now. Recently, you started hearing about different API design architectures or web services implementations like REST, GraphQL or JSON:API. In this session, we will take a look at the basics of these, with the help of hands-on examples.
In this session, we will learn about:
- Defining API strategy and architecture
- Improving the developer experience of building and consuming an API
- Lifecyle of API management
- Comparison of REST, GraphQL and JSON:API
- Drupal-specific implementation details for these
Different products need different API architectural styles to reach desired objectives, and there is no single silver bullet to solve this. It’s important to understand the multiple styles for architecting APIs, and to know which one to use when. By the end of this session, you will be able to compare where to use REST and where to use GraphQL, based on your constraints.
Intro to Essentials for creating a Decoupled Drupal application (Resources, authentication, normalization, sub-requests)
Let's get you started on your first decoupled project!
The internet is evolving and so is Drupal. We are in a world where one Drupal web application can be the source to populate content on many channels like websites, mobile apps, IoT devices, etc.
To make our web applications future-proof and create world-class digital experiences, knowing about REST and decoupled Drupal has become fundamental.
At the end of this session, you'll have better knowledge about these concepts:
- REST resources
- Resource plugins
- Normalization and serialization
- React setup
- CRUD operations
- Requests and sub-requests
- Pros and cons of decoupling
- Variables declaration
- Multiline strings
- Template literals
- Arrow functions
- Promises/async functions
Apart from programming aspects, we will quickly touch base on those topics which could help during theme and application development.
- Package management
- Build systems and task runners
- Working with Git
How we delivered a multi-site, multilingual decoupled Drupal project in record time
Our engagement with a leading global agency—to overhaul their client's multiple websites across multiple brands—was challenging in many ways, especially since we didn't have a team familiar with the technology at the start. What we had was prior experience building decoupled applications; robust, agile management practices; and a strong decoupled (read 'remote') work culture in place.
In this session, we'll see how we scaled up and conquered these challenges to deliver the client's headless Drupal solution successfully—all within a timespan of just a few months.
We'll cover how a robust agile project methodology brought sanity to this engagement which involved multiple stakeholders, along with how decoupled teams enabled parallel independent work streams based on established communication protocols.
We will also look at some of the crucial technical aspects of the project, along with the business case supporting them:
- Component-driven architecture using Angular as a front-end
- 7-step content moderation workflow supporting multi-geography based compliance requirements
- A unique deployment architecture across multiple infrastructures (Amazon Web Services, Alibaba Cloud) with Lambda-based proxy
- CI pipeline built on Jenkins with Terraform used for front-end infrastructure
Testing your front-end application to production
Building a decoupled application is one half of the story before you can deploy it to production. To make sure you have a sturdy application, you will have to test it on multiple fronts. You will have to test various types of components, async operations, integration between multiple components, and a lot more.
In this example-driven session, you will learn how to drive an application from no tests to multiple unit, snapshot, and integration tests without breaking a sweat.
In this session, you will learn:
- Various ways to test your components—we will be using React as an example here
- How snapshot testing can help you keep looking at the UI every time you make a change
- Writing integration tests to make sure all the components are working with each other
- Bonus: how type checking can help you refactor and find problems at compile time
Building a component-driven architecture using Drupal and Angular
Component-driven development has become ubiquitous among developers as it allows us to architect large systems by combining granular components. This gives us an opportunity to mix and match components together to form a plethora of variations. Apart from this, it allows us to easily refactor these components to change the behavior without affecting the whole system, and with that, testing them becomes really simple.
In this session, we will see how Drupal and Angular can be used together to build components that can be combined together to build decoupled applications.
- Using paragraphs to build components
- Writing a custom normalizer to override response from JSON API
- Rendering components dynamically based on API response
- Adding support for multiple languages
Build infrastructure for a multi-site Decoupled Drupal solution using Terraform
While hosting a Drupal website can be a challenge, it is largely a solved problem with several PaaS providers providing optimized Drupal hosting. Even if we didn't want to use that, there is extensive documentation around best practices in hosting a PHP application or Drupal specifically.
In a decoupled Drupal setup, we would need to even host the front-end application separately somewhere apart from Drupal. In this session, we will discuss how we hosted a "serverless" front-end application with multiple cloud providers available via a CDN while allowing it to access Drupal's API endpoints on the edge (again with FaaS computing paradigm). We will also discuss the developer constraints, security considerations, and website performance.
Further, we will also see how such an application can be provisioned multiple times in different regions of more than one cloud provider using Terraform. We will talk about using Terraform and writing wrapper scripts for Terraform to make it easier and more consistent to deploy the infrastructure. We will also discuss how much of this setup can be automated, considering enterprise security regulations, developer effectiveness, and customizations.
In this session, you will learn how to:
- Plan your API contract across multiple websites in a multi-site Drupal setup
- Architect a "serverless" solution to serve the front-end with data retrieved via an API from Drupal
- Use Terraform to build this setup
- Run Terraform modules using a wrapper script or even via a CI tool
- Understand enterprise-level security considerations such as IP whitelisting the access to Drupal server, firewall, granular access to cloud resources, etc
Design a CI and CD workflow for both front-end and the Drupal back-end in a Decoupled Drupal solution
A typical Drupal website today needs a moderately sized team. In fact, there would most likely be more than one team in case of decoupled Drupal solutions. A team of any size (even size of one) needs automation and standard workflows. There is probably no developer workflow for automation more ubiquitous than using continuous integration in some fashion.
In the vast landscape of CI/CD tools available today, it is difficult to pick the right tool or even the right workflow for your team. In this session, I will talk about one workflow we adopted for a recent decoupled Drupal solution with multi-site architecture and multiple front-ends. I will describe how we use Jenkins to run builds and deployments to certain environments for an Acquia Cloud Site Factory hosted Drupal back-end and multiple Angular front-end websites hosted on multiple cloud providers. We will also discuss the testing strategy for the code before deployment.
Further, we will discuss specific methods where we can reuse the Jenkins pipeline definition code in multiple repositories to help maintainability. We will talk about how we would use Docker to run containers with specific build and test tools rather than installing it on the Jenkins server and using tools like BLT as part of this process.
In this session, you will learn about:
- What components are required in building a build toolchain
- Using Jenkins to configure builds and writing a scripted pipeline
- Using Docker to run tools without installing it on the Jenkins server
- Sharing pipeline code across multiple repositories for back-end and front-end
- Deploying code and even provisioning infrastructure conditionally and securely
We hope you find these topics interesting. Whatever is selected, we're happy to answer your questions and provide more information on each topic. Feel free to comment below!