DEV Community: Norby Baruani

Ensuring Scalable Application Design and Development: A Comprehensive Guide

Norby Baruani — Tue, 04 Jun 2024 18:30:08 +0000

In today's digital age, applications are vital in driving business success. However, as the user base and data volume increase, many applications struggle to meet the demand, leading to performance and scalability problems. Ensuring scalable application design and development is crucial to handle growing traffic, data, and user engagement.

Why Scalability Matters

Scalability is an application's ability to handle increased load and demand without compromising performance, security, or user experience.

Types of Scalability

Horizontal Scalability (Scale-Out):
- Involves adding more machines or instances to your application's infrastructure.
- Utilizes techniques like load balancing and distributed computing to spread workloads.
- Offers flexibility and cost-effectiveness by adding inexpensive hardware as needed.
Vertical Scalability (Scale-Up):
- Involves enhancing the resources of existing servers (e.g., increasing CPU, RAM).
- Provides a straightforward solution but can be limited by hardware capacity and higher costs.

Benefits of Scalability

A scalable application design ensures:

High availability: The application remains accessible and responsive even during peak usage or unexpected traffic spikes.
Improved user experience: Scalable applications ensure fast load times, reduced latency, and seamless navigation, leading to increased user satisfaction and engagement.
Cost savings: Scalable designs reduce the need for costly hardware upgrades or infrastructure changes as the application grows.
Competitive advantage: Scalable applications can handle sudden surges in traffic, giving businesses a competitive edge in the market.

Designing for Scalability

To ensure scalable application design and development, follow these best practices:

Modular Architecture
Break down the application into smaller, independent modules or microservices, each responsible for a specific function. This allows for easier maintenance, updates, and scalability.
Cloud-Native Approach
Leverage cloud-native technologies and services, such as serverless computing, containers, and Kubernetes, to take advantage of on-demand scalability and reduced infrastructure costs.
Database Optimization & Scalability
Design databases for scalability by using NoSQL databases, sharding, and data replication to ensure efficient data storage and retrieval.
Caching and Content Delivery Network
Implement caching mechanisms by storing frequently accessed data to improve response times and distribute content delivery across global servers to reduce latency and enhance geographically dispersed users' performance.
Load Balancing and Autoscaling
Use load balancers to distribute traffic efficiently and autoscaling to adjust resources based on demand automatically.
Microservices Architecture
Breaking down the application into smaller, independent services can enhance scalability and fault tolerance.
APIs and Integration
Efficiently designed APIs and third-party integrations can improve performance and scalability.

Development Best Practices

In addition to design considerations, follow these development best practices to ensure scalability:

Future-Proofing Strategies
Ensure the app architecture can adapt to technological advancements.
Containerization and Orchestration
Using containers (e.g., Docker) and orchestration tools (e.g., Kubernetes) can streamline application components' deployment, management, and scaling.
Capacity Planning and Performance Benchmarking
Regular capacity planning and performance benchmarking help identify potential bottlenecks and inform scaling decisions.
Monitoring and Observability
Use tools to track performance metrics and detect issues in real time.
Scalability Testing & Planning
Conduct performance, load, and stress testing. Develop a comprehensive plan outlining scaling strategies.
Optimization Techniques
Implement caching, asynchronous processing, and distributed computing.
Ongoing Support
Ensure continuous scalability consulting and maintenance.
Budget Allocation
Allocate budget on resources for scalability testing and optimizations.
Collaboration and Communication
Maintain transparent communication regarding scalability initiatives.
User Feedback Integration
Incorporate user feedback to guide scalability decisions.

Conclusion

Ensuring scalable application design and development is crucial for businesses to stay competitive in today's fast-paced digital landscape. Following this article's design principles and development best practices, you can build applications that easily handle growth, provide an excellent user experience, and drive business success.

How to use Traits, Interface, and Abstract classes In PHP

Norby Baruani — Fri, 31 May 2024 10:00:55 +0000

As a software developer, writing reusable and maintainable code is crucial. PHP provides several tools to help achieve this, including Traits, Interfaces, and Abstract Classes. In this article, we'll explore each concept, their differences, and how to use them effectively.

Trait

Traits are a way to reuse code in PHP. They are similar to abstract classes but with a few key differences. Traits are used to group related methods that can be used in multiple classes.

Defining a Trait

To define a trait, use the trait keyword followed by the trait name:

trait LoggerTrait {
    public function log(string $message): void {
        echo $message . "\n";
    }
}

Using a Trait

To use a trait in a class, use the use keyword:

class MyClass {
    use LoggerTrait;
}

Now, the MyClass class has access to the log method.

Interfaces

Interfaces define a contract that must be implemented by any class that implements it. They represent a set of methods that must be implemented but do not provide any implementation.

Defining an Interface

To define an interface, use the interface keyword followed by the interface name:

interface Printable {
    public function print(): void;
}

Implementing an Interface

To implement an interface, use the implements keyword:

class MyClass implements Printable {
    public function print(): void {
        echo "Printing...\n";
    }
}

Abstract Classes

Abstract classes are similar to interfaces but can also provide an implementation for some methods.

Defining an Abstract Class

To define an abstract class, use the abstract keyword followed by the class name:

abstract class AbstractClass {
    public function doSomething(): void {
        echo "Doing something...\n";
    }

    abstract public function doSomethingElse(): void;
}

Extending an Abstract Class

To extend an abstract class, use the extends keyword:

class MyClass extends AbstractClass {
    public function doSomethingElse(): void {
        echo "Doing something else...\n";
    }
}

Final Code Sample

Here is an example of a class that uses all the concepts we've discussed:

// Trait
trait LoggerTrait {
    public function log(string $message): void {
        echo $message . "\n";
    }
}

// Interface
interface Printable {
    public function print(): void;
}

// Abstract Class
abstract class AbstractClass {
    public function doSomething(): void {
        echo "Doing something...\n";
    }

    abstract public function doSomethingElse(): void;
}

// Concrete Class that uses everything
class MyClass extends AbstractClass implements Printable {
    use LoggerTrait;

    public function print(): void {
        echo "Printing...\n";
    }

    public function doSomethingElse(): void {
        echo "Doing something else...\n";
    }

    public function doSomethingWithLogging(): void {
        $this->log("About to do something...");
        $this->doSomething();
        $this->log("Done doing something!");
    }
}

// Using the class
$myClass = new MyClass();

$myClass->print(); 
// Outputs: Printing...

$myClass->doSomething(); 
// Outputs: Doing something...

$myClass->doSomethingElse(); 
// Outputs: Doing something else...

$myClass->doSomethingWithLogging(); 
// Outputs:
// About to do something...
// Doing something...
// Done doing something!

In this example, MyClass:

Extends the AbstractClass, which provides the doSomething() method and requires the implementation of the doSomethingElse() method.
Implements the Printable interface, which requires the implementation of the print() method.
Uses the LoggerTrait, which provides the log() method.

The MyClass class uses all the concepts we've discussed and demonstrates how they can work together to provide a robust and maintainable class.

Conclusion

This article shows how to use Traits, Interfaces, and Abstract Classes in PHP. Traits provide a way to reuse code, Interfaces define a contract that must be implemented, and Abstract Classes provide a way to define a base class with some implementation.

Idempotent API Design

Norby Baruani — Tue, 06 Jun 2023 12:29:51 +0000

Overview

Idempotent API design refers to the practice of designing an API in such a way that multiple identical requests have the same effect as a single request. In other words, if the same request is made multiple times, the result will be the same as if the request was only made once.

Idempotent APIs are particularly useful in distributed systems where requests may be retried or duplicated due to network issues or other transient failures. By ensuring that repeated requests have no additional effect, idempotent APIs can prevent unintended side effects and ensure data consistency.

To achieve Idempotency, APIs typically assign a unique identifier (such as a UUID) to each request, and use this identifier to identify and de-duplicate duplicate requests. This can be done either by storing the result of the initial request and returning it for subsequent requests, or by ensuring that the API operation is atomic and can be safely repeated without causing additional side effects.

Overall, designing idempotent APIs can help improve the reliability and consistency of distributed systems, and is an important consideration for any API design.

Use case

Here are some examples of idempotent API design using Node.js:

1. Using HTTP GET in REST APIs

HTTP GET is an idempotent method in REST APIs. In the following example, we use Node.js to perform an HTTP GET request to retrieve a user's profile:

const https = require('https');

const options = {
  hostname: 'api.example.com',
  path: '/users/123',
  method: 'GET'
};

const req = https.request(options, res => {
  console.log(`statusCode: ${res.statusCode}`);

  res.on('data', d => {
    process.stdout.write(d);
  });
});

req.on('error', error => {
  console.error(error);
});

req.end();

In this example, we make an HTTP GET request to api.example.com to retrieve the user with ID 123. The options object is used to specify the HTTP method, hostname, and path. If the request is retried, it will return the same response, since the GET method is idempotent.

2. Using HTTP POST with Idempotency keys

HTTP POST requests are not idempotent by default, but we can make them idempotent by using an idempotency key. In this example, we use Node.js to perform an HTTP POST request to create a new payment, and include an idempotency key in the request headers:

const https = require('https');

const options = {
  hostname: 'api.example.com',
  path: '/payments',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Idempotency-Key': 'abc123'
  }
};

const data = {
  amount: 100,
  currency: 'USD'
};

const req = https.request(options, res => {
  console.log(`statusCode: ${res.statusCode}`);

  res.on('data', d => {
    process.stdout.write(d);
  });
});

req.on('error', error => {
  console.error(error);
});

req.write(JSON.stringify(data));
req.end();

In this example, we create a new payment by sending an HTTP POST request to api.example.com/payments, and include an idempotency key of abc123 in the request headers. The data object contains the payment details. If the request is retried with the same idempotency key, the server will ignore the duplicate request and return the same response as before.

3. Using HTTP PUT in REST APIs

HTTP PUT requests are also idempotent in REST APIs, since they are used to update resources. In this example, we use Node.js to perform an HTTP PUT request to update a user's profile:

const https = require('https');

const options = {
  hostname: 'api.example.com',
  path: '/users/123',
  method: 'PUT',
  headers: {
    'Content-Type': 'application/json'
  }
};

const data = {
  name: 'Alice'
};

const req = https.request(options, res => {
  console.log(`statusCode: ${res.statusCode}`);

  res.on('data', d => {
    process.stdout.write(d);
  });
});

req.on('error', error => {
  console.error(error);
});

req.write(JSON.stringify(data));
req.end();

In this example, we update the user with ID 123 by sending an HTTP PUT request to api.example.com/users/123, and including the updated name in the request body. If the request is retried, it will return the same response as before, since the PUT method is idempotent.

Pros an Cons

There are several advantages and some potential disadvantages to consider when designing APIs with Idempotency in mind.

Here are some pros and cons:

Pros of idempotent API design

Reduces the likelihood of data corruption: By ensuring that requests can be safely retried, idempotency helps to minimize the risk of data corruption that can occur when requests are duplicated.
Simplifies error handling: Because idempotent requests should return the same response regardless of how many times they are retried, error handling can be simplified.
Improves scalability: Idempotent APIs can be easier to scale since they allow for retries without duplicating data.
Facilitates caching: Idempotent requests can be cached, reducing server load and improving performance.
Makes APIs more predictable: Idempotency provides a consistent and predictable behavior for APIs, regardless of how many times a request is submitted.

Cons of idempotent API design

May increase complexity: Idempotent APIs can require additional logic to handle retries and idempotency keys, which can make them more complex to implement.
Can increase latency: Adding an idempotency key to each request can increase the size of the payload, which may cause latency issues for large requests.
Not suitable for all use cases: Not all API calls can be made idempotent, so it may not be appropriate to design every API with idempotency in mind.

Overall, the benefits of designing APIs with idempotency in mind can outweigh the potential drawbacks. However, it is important to carefully consider the requirements and constraints of each use case before implementing an idempotent API design

Futuristic Databases

Norby Baruani — Mon, 24 Apr 2023 06:10:25 +0000

Modern database paradigms Most popluar new databases Alternatives to SQL RDBMS Artificial Intelligence embedded in databases

1. Relational Databases

Popular options include MySQL, PostgreSQL. They are the most popular types of databases today. They use sql which allows you to access and write data in the database. However, they require a schema so if you don't know the shape of data upfront they can be a little hard to work with. They are also ACID compliant which means when there is a transaction in the database, volidity is guaranteed even when there are network and hardware failures

Planetscale

PlanetScale is a MySQL-compatible serverless database that brings you scale, performance, and reliability — without sacrificing developer experience. With PlanetScale, you get the power of horizontal sharding, non-blocking schema changes, and many more powerful database features without the pain of implementing them.

YugabyteDB

YugabyteDB is a transactional database that brings together four must-have needs of cloud native apps - namely SQL as a flexible query language, low-latency performance, continuous availability, and globally-distributed scalability. Other databases do not serve all 4 of these needs simultaneously.

NeonDB

Neon is an open-source (Apache 2.0) alternative to AWS Aurora or Google's Cloud SQL for Postgres. Neon is a serverless, scalable implementation of PostgreSQL that you can run on-premise or try through its managed service. Neon decomposes the PostgreSQL architecture into two layers: compute and storage

Dolt

Dolt is the first and only SQL database that you can fork, clone, branch, merge, push and pull just like a Git repository. Dolt is a version controlled database. Dolt is Git for Data. Dolt is a Versioned MySQL Replica. Dolt implements the Git command line and associated operations on table rows instead of files.

CockroachDB

A distributed SQL database for cloud services. CockroachDB is built on consistent key-values, horizontal scalability, and to survive datacenter, disk or machine failures with minimal disruptions due to replication and automated repair features. It is more suitable in the cases of multi-datacenter and -region deployments, cloud migrations, cloud-native infrastructure, and replicated or distributed OLTP (online transaction processing), rather than for heavy analytics.

Cloudflare D1

Built on SQLite, D1 is Cloudflare's first queryable relational database Open external link . Create an entire database in a few quick steps by importing data or defining your tables and writing your queries within a Worker or through our API.

Xata

Xata is a Serverless Data Platform. It combines the features of a relational database, a search engine, and an analytics engine and exposes a single consistent REST API. Xata has first-class support for branches, a workflow for zero-downtime schema migrations, and edge caching.

8base

A fully-managed, cloud-based data and serverless compute service exposed through a GraphQL API. A cloud service designed to power enterprise-grade web and mobile applications that require support for large numbers of users, complex data and transactional requirements, comprehensive role-based security and a modern look-and-feel.

2. Multi-model (also known as PostSQL or NewSQL) Database

A multi-model database is a management system that combines multiple database types with a single backend. Most database management systems support only a single database model. On the other hand, multi-model databases store, query, and index data from different models.

Multi-model databases provide the modeling advantages of polyglot persistence without having to find ways to combine different models. The flexible approach allows storing data in different ways

EdgeDB

EdgeDB is the first open-source, graph-relational database designed as the successor to SQL and the relational paradigm. EdgeDB uses the Graph Relational Model, where data is described and stored as strongly typed objects, and relationships link through objects.

SurrealDB

SurrealDB is an innovative NewSQL cloud database, suitable for serverless applications, jamstack applications, single-page applications, and traditional applications. It is unmatched in its versatility and financial value, with the ability for deployment on cloud, on-premise, embedded, and edge computing environments.

FaunaDB

Fauna is the only serverless, globally distributed cloud database that combines the flexibility of NoSQL systems with the relational querying and ACID consistency of SQL databases.

3. Graph Database

A graph database stores nodes and relationships instead of tables, or documents. Data is stored just like you might sketch ideas on a whiteboard.

Lets imagine you want to create a many to many relationship in a relational database, we do that by setting up a join table with a foreign key that defines that relationship in a graph database we do no need that middle man table we just define an edge and connect to the other record. We can now query this data with a statement that is more concise and readable in addition we can achieve better performance on large datasets. They can be a great alternative for sql especially if you are working with a lot of joins and performance is taking a hit because of that. They are often used for fraud detection in finance, building internal knowledge graphs within companies and to power recommendation engines like Airbnb.

Neo4j

Neo4j is the world's leading open source Graph Database which is developed using Java technology. It is highly scalable and schema free (NoSQL).

Memgraph

Memgraph is a graph database, optimized to run both transactional and analytical graph workloads with low latency and high performance. It's compatible with both the Bolt protocol and the openCypher graph query language, making it interoperable with a wide range of technologies.

4. Search Database

Most of the databases in this paradigm are built on top of the the apache Lucene project which has been around since 1999 like solr, Elastic Search.

They work very similar to a document oriented Database, you start with an index, then you add a bunch of data objects to it. The difference is that under the hood the search database will analyze all the text in the document and create an index of the searchable items.

They can be expensive to run at scale however they can add a ton of value to the user experience for a search feature

Meilisearch

Meilisearch is a flexible and powerful user-focused search engine that can be added to any website or application.

MeiliSearch lets you create filters to narrow down your search results based on user-defined criteria. Faceted search helps you to categorize search results and create user-friendly navigation interfaces. Users can choose which types of results they wish to see first by sorting search results at query time.

5. Key-value Databases

A key-value database (sometimes called a key-value store) uses a simple key-value method to store data. It's a type of NoSQL database that stores data as a collection of key-value pairs. These databases contain a simple string (the key) that is always unique and an arbitrary large data field (the value). They are easy to design and implement.

Popular databases in this space include Redis, Memcached. They are designed for high performance and scalability, and are often used in situations where the data does not require complex relationships or joins.

KeyDB

KeyDB is an open source, in-memory data structure store, used as a database, cache and message broker. It supports data structures such as strings, hashes, lists, sets, sorted sets with range queries, bitmaps), hyperloglogs, geospatial indexes with radius queries and streams.

7. Machine Learning Database

The Machine Learning Database, or MLDB, is an open-source system aimed at tackling big data machine learning tasks. It can be used for data collection and storage through the training of machine learning models, or to deploy real-time prediction endpoints. MLDB is one of the easier datasets to use, since it provides a comprehensive implementation of the SQL SELECT statement. This means it treats datasets as tables, making it easier to learn and use for data analysts already versed in an existing Relational Database Management System (RDBMS).

MindsDB

MindsDB enables you to use your data and make forecasts. It speeds up the ML development process by bringing machine learning into the database. With MindsDB, you can build, train, optimize, and deploy your ML models without the need for other platforms. And to get the forecasts, simply query your data and ML models.

6. Document Oriented Database

A document database is a type of NoSQL database that stores data in the form of documents, rather than in tables with rows and columns like a traditional relational database. These documents can be in a variety of formats, such as JSON, BSON, or XML.

They often include nested data structures, which can make it easier to store and query complex data. Document databases are well suited for storing semi-structured data and are often used in web and mobile applications. They offer a flexible schema and high performance, but may have limited querying capabilities compared to relational databases and difficulties with data consistency and validation.

Laravel Eloquent ORM 2-in-1 Methods

Norby Baruani — Mon, 28 Nov 2022 11:31:10 +0000

Overview

Eloquent is an object-relational mapper (ORM) that makes it enjoyable to interact with your database.

ORM allow us to have a neat structure within our codebase with concept of Models. A Model in this case will be a representation of a database row as well as entity relationship.

Concepts

A Model has mainly 3 responsibilities:

Manage persistence of data and relationship
Hold data in Memory
Implement business logic

We will be focusing on some useful methods in Eloquent which encapsulate 2 responsibility in one. The benefit of this is it reduces codes and conditional statements in your logic.

2-in-1 Functions

Retrieving Or Creating Record

firstOrCreate() will attempt to retrieve a record using the given data. However in case the record was not found, new record will be created and persisted to the database using given data.
firstOrNew() similar to firstOrCreate() however if no records were found a new instance of the model will be returned with the given data but data will not automatically be persisted. A manual intervention will be required by calling save() methods on the instance returned.

use App\Models\Flight;

// Retrieve flight by name 
// or create it if it doesn't exist...
$flight = Flight::firstOrCreate([
    'name' => 'London to Paris'
]);

// Retrieve flight by name 
// or create it with the name, delayed, and arrival_time attributes...
$flight = Flight::firstOrCreate(
    ['name' => 'London to Paris'],
    ['delayed' => 1, 'arrival_time' => '11:30']
);

// Retrieve flight by name 
// or instantiate a new Flight instance...
$flight = Flight::firstOrNew([
    'name' => 'London to Paris'
]);

// Retrieve flight by name 
// or instantiate with the name, delayed, and arrival_time attributes...
$flight = Flight::firstOrNew(
    ['name' => 'Tokyo to Sydney'],
    ['delayed' => 1, 'arrival_time' => '11:30']
);

Updating Or Creating Records

updateOrCreate() will attempt to update a record using the given data. However in case the record was not found, new record will be created and persisted to the database using given data.

use App\Models\Flight;

// Update flight where departure and destination with price and discounted 
// or create new record with departure, destination, price and discounted
$flight = Flight::updateOrCreate(
    ['departure' => 'Oakland', 'destination' => 'San Diego'],
    ['price' => 99, 'discounted' => 1]
);

Updating Or Creating Records (Batch)

upsert() Enable us to inserts multiple rows into a database table if they do not already exist, or updates them if they do in a single query.

use App\Models\Flight;

// The method's first argument consists of the values to insert or update, 
// while the second argument lists the column(s) that 
// uniquely identify records within the associated table.

// While the third argument is an array of the columns 
// that should be updated if a matching record 
// already exists in the database.
Flight::upsert(
    [
        ['departure' => 'Oakland', 'destination' => 'San Diego', 'price' => 99],
        ['departure' => 'Chicago', 'destination' => 'New York', 'price' => 150]
    ],
    ['departure', 'destination'],
    ['price']
);

AWS EventBridge Overview

Norby Baruani — Tue, 18 Oct 2022 21:19:05 +0000

What is Amazon EventBridge?

Amazon EventBridge is a new service that changed how we develop Serverless applications.

This service allow us to develop a fully event-driven application by connecting multiple services together - AWS services, custom services and third party services.

EventBridge was formerly called Amazon CloudWatch Events. Amazon CloudWatch Events and EventBridge are the same underlying service and API, however, EventBridge provides more features.

How it works

EventBridge delivers a stream of real-time data from AWS services, SaaS applications and your own applications to different types of targets without writing code.

The publisher sends a JSON event to an event bus, and to receive events, you create a rule. If the published event matches with a rule, the event is routed to up to five targets.

EventBridge is directly integrated with over 130 event sources and over 35 targets.

EventBridge Features

EventBridge Building Blocks

Events

An event is a real-time change in a system, data, or environment. This change can be either in your application or in an AWS service or a SaaS partner service.

Event sources

An event source is used to ingest events from a SaaS partner, AWS Services, or your own applications.

Event buses

An event bus is a pipeline that receives events. Rules associated with the event bus evaluate events as they arrive. Each rule checks whether an event matches the rule’s criteria.

Event Bus Types:

Default event bus: Default bus created and receives events from any AWS service
Custom event bus: Receives events from custom applications you created and must be created manually
Partner event bus: Receives events from SaaS partner applications and must be created manually.

Rules

A rule matches incoming events and sends them to targets for processing. A single rule can send an event to multiple targets, which then run in parallel. Rules are based either on an event pattern or a schedule.

Targets

A target is a resource or endpoint that EventBridge sends an event to when the event matches the event pattern defined for a rule. The rule processes the event data and sends the pertinent information to the target. To deliver event data to a target, EventBridge needs permission to access the target resource. You can define up to five targets for each rule.

Laravel Passwordless Authentication

Norby Baruani — Tue, 18 Oct 2022 21:18:40 +0000

Passwordless authentication is a method whereby users access an app without entering passwords. It is the most effective way to reduce risky password management practices and prevent credential theft attacks.

Above is an architecture diagram of a Passwordless authentication flow.

we will be using this laravel package laravel-passwordless-authentication to implement a passwordless authentication by sending a magic link to the user's email address to authenticate them.

Install

Setup new Laravel application

composer create-project laravel/laravel passwordless-app

Install Laravel Breeze to scaffold quick UI

composer require laravel/breeze --dev

php artisan breeze:install

php artisan migrate
npm install
npm run dev

Install passwordless package and follow instruction to setup package.

composer require norbybaru/passwordless-auth

php artisan vendor:publish --provider="NorbyBaru\Passwordless\PasswordlessServiceProvider" --tag="passwordless-config"
php artisan vendor:publish --provider="NorbyBaru\Passwordless\PasswordlessServiceProvider" --tag="passwordless-migrations"

php artisan migrate

1. Mail driver Setup

Setup mail driver with mailtrap.io. Copy below values into your .env and replace MAIL_USERNAME and MAIL_PASSWORD with your correct credentials from mailtrap.io.

MAIL_MAILER=smtp
MAIL_HOST=smtp.mailtrap.io
MAIL_PORT=2525
MAIL_USERNAME=
MAIL_PASSWORD=
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS=support@example.test
MAIL_FROM_NAME="${APP_NAME}"

2. User Model Setup

Setup User model to work with laravel-passwordless-authentication package by extending CanUsePasswordlessAuthenticatable::class and implementing PasswordlessAuthenticatable::class on the model.

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use Laravel\Sanctum\HasApiTokens;
use NorbyBaru\Passwordless\CanUsePasswordlessAuthenticatable;
use NorbyBaru\Passwordless\Traits\PasswordlessAuthenticatable;

class User extends Authenticatable implements CanUsePasswordlessAuthenticatable
{
    use HasApiTokens, HasFactory, Notifiable, PasswordlessAuthenticatable;
...
}

3. Login Form

Update login form to capture only email address of user as an identifier to send magic link to login.

4. Login Route

Update login route in routes/auth.php to require an email address and use laravel-passwordless-authentication package to send magic link token.

Route::post('login', function (Request $request) {
        $validated = $request->validate([
            'email' => 'required|email|exists:users|max:255',
        ]);

        $status = Passwordless::magicLink()->sendLink($validated);

        return redirect()->back()->with([
            'status' => trans($status)
        ]);
    });

5. Update Translation

Add file passwordless.php under translation directory lang/en/passwordless.php with the following values to show correct message back to user depending on response status from sending magic link to user.

<?php

return [
    'sent' => 'Login link sent to inbox.',
    'throttled' => 'Login link was already sent. Please check your inbox or try again later.',
    'invalid_token' => 'Invalid link supplied. Please request new one.',
    'invalid_user' => 'Invalid user info supplied.',
    'verified' => 'Login successful.',
];

Final Steps

Start your application and make sure to create or seed some dummy user to test login flow with them.

Laravel Vapor Multiple Deploy File to different AWS account or region

Norby Baruani — Wed, 18 Aug 2021 16:29:10 +0000

Brief Description

Will be sharing how I was able to deploy same codebase to different AWS account on Vapor using multiple vapor.yml config file with the help of bash scripts.

At the time of writing this, Laravel Vapor did not support deploy command to receive a filepath to deploy against. Hopefully one day that feature can be added by the team.

These approach allows you to use separate AWS account for your staging and production environments if needed as well better than that deploy to multiple aws account or multiple aws region.

How it works

Assuming you already have your laravel project setup and working with Laravel Vapor.

Rename vapor.yml to vapor.{account}.yml, project should be a unique name different to the other file you need to create. eg. vapor.dev.yml 2.Create another vapor config file to deploy to the different account or region. eg. vapor.devcon.yml and make sure config are correct.
Make sure vapor.yml file doesn't exist on your root directory of project anymore.
Copy the following scripts to the root directory of project and make sure to make them executable.

Interact with scripts

At this stage you should have 2 vapor config file on your root directory. From our example you would have:

vapor.dev.yml
vapor.devcon.yml

Vapor CLI:

./vapor-cli.sh dev env:pull staging
./vapor-cli.sh dev env:push staging

Deploy:

./vapor-deploy.sh dev staging
./vapor-deploy.sh devcon production

Take Away

This approach can be used to deploy Staging and Production to different AWS account or Region as well.

All that will be

To have correct file naming and config to have only correct environment setting on the related file.
To make changes to both script by to only allow 1 argument and use 1st argument as filename and environment to run against.

Eg.

vapor.staging.yml
vapor.production.yml

./vapor-deploy.sh staging
./vapor-deploy.sh production