DEV Community: Emanuel Navarro

How to Easily Dockerize a Next.js Application

Emanuel Navarro — Mon, 10 Jun 2024 00:31:18 +0000

Hi there! In this little post I'm going to show you how to use Docker to containerize your Next.js application.

What is Docker?

Docker is an open-source platform that enables developers to automate the deployment, scaling, and management of applications inside lightweight, portable containers. Containers are a way to package applications with their dependencies and runtime environment, allowing them to run consistently across different environments, such as development, testing, and production, without any compatibility issues.

Setting up a Next.js project

1.First we need to create a nextjs application.

npx create-next-app@latest project_name

2.Create Dockerfile in the root directory of your project

//Dockerfile

FROM node:18-alpine

# Initialize a working directory in your new os
WORKDIR /app

# Copy package.json into the new working directory
COPY package*.json ./

RUN npm install

# Copy all the files from your current directory to the working directory of the container
COPY . .

# Expose port 3000 from your container to local network
EXPOSE 3000

CMD npm run dev

3.Create the docker container

docker build -t next-docker-demo .

Where next-docker-demo is the image name.

. to tell docker that the Dockerfile is in current folder.

4.We can use docker compose, so we don’t need to remember long commands to build or run containers. We can simply just use docker-compose build and docker-compose up.

Add a docker-compose.yml file to your root directory.

version: '3.8'
services:
  app:
    image: next-docker-demo
    build: .
    volumes:
        - .:/app
        - /app/node_modules
        - /app/.next
    ports:
      - "3000:3000"

docker-compose build

docker-compose up -d

-d to run the the container in the background.

Now if you access http://localhost:3000, you will see your working app!

Integrate Snowflake with Laravel

Emanuel Navarro — Mon, 03 Jun 2024 21:29:55 +0000

Snowflake is a cloud-based data warehousing service that offers high performance, scalability, and flexibility for managing large volumes of data. Using the offical pdo driver, PHP applications can directly interact with Snowflake, enabling seamless execution of queries and retrieval of data.

In order to integrate Snowflake with our Laravel application using PostgreSQL we're going to use the laravel-pdo-odbc package and the pdo_snowflake PHP PDO driver from snowflake.
At the end of the post I leave a script with all the steps to build and install the driver in a Dockerfile.

NOTE: Snowflake PHP PDO driver does not yet support ARM/AARCH64 architecture on Linux.

PHP PDO Driver

First we have to build and install the pdo driver.

Prerequisites

To build the Snowflake PHP PDO Driver, we need to have installed the following software:

On Linux:

PHP 8.1 or higher (Note: support for PHP 8.0 or lower is deprecated).
gcc 5.2 or higher.
cmake 2.8 or higher

And the following php modules:

php-pdo
pdo_pgsql
pdo_odbc

Building the Driver

1.Set the PHP_HOME environment variable to the path to the bin directory containing the phpize executable. For example, if the phpize executable is in /usr/local/bin, run the following command:

export PHP_HOME=/usr/local

2.Clone the pdo_snowflake repository, and run the script to build the driver:

git clone https://github.com/snowflakedb/pdo_snowflake.git
cd pdo_snowflake
./scripts/build_pdo_snowflake.sh

To verify that the driver was succesfully built, run the next command:

$PHP_HOME/bin/php -dextension=modules/pdo_snowflake.so -m | grep pdo_snowflake

It should appear pdo_snowflake in the output from the command.

Installing the Driver

1.Copy pdo_snowflake.so from the modules subdirectory in the repository to the PHP extension directory.

cp modules/pdo_snowflake.so /usr/local/lib/php/extensions/no-debug-non-zts-*/

2.Copy cacert.pem from the libsnowflakeclient subdirectory in the repository to the PHP configuration directory containing the PHP configuration files. To find the PHP configuration directory, you can use this command $PHP_HOME/bin/php -ini.

cp ./libsnowflakeclient/cacert.pem /usr/local/etc/php/cacert.pem

3.In the same directory that contains the PHP configuration files, create a config file named pdo_snowflake.ini that contains the following settings:

extension=pdo_snowflake.so
pdo_snowflake.cacert=<path to PHP config directory>/cacert.pem

4.If you are using PHP with an application server or web server (e.g. Apache or nginx), restart the server.

Integrating the PHP Driver in Laravel

Once we have the driver set up we need to install the package to make the integration with laravel.

1.To add the package to your project, run the following command:

composer require yoramdelangen/laravel-pdo-odbc

2.Register the service provider in the app file from you project:

// app.php

'providers' => [
  // ...
  LaravelPdoOdbc\ODBCServiceProvider::class,
];

3.Add a Database configuration into the database file:

// database.php

'snowflake' => [
    'driver' => 'snowflake_native',
    'account' => '{account_name}.eu-west-1',
    'username' => '{username}',
    'password' => '{password}',
    'database' => '{database}',
    'warehouse' => '{warehouse}',
    'schema' => 'PUBLIC', // change it if necessary.
    'options' => [
        // Required for Snowflake usage
        \PDO::ODBC_ATTR_USE_CURSOR_LIBRARY => \PDO::ODBC_SQL_USE_DRIVER
    ]
],

4.Finish! Now you can use Eloquent ORM, and other Illuminate components as usual.

# Facade
$users = DB::connection('snowflake')
            ->table('users')
            ->where('created_at', '>', '2024-03-15')
            ->get();

# ORM
$users = User::all();

To know more about the PHP pdo driver and the laravel package, you can check the documentation here:

PHP PDO drive: https://github.com/snowflakedb/pdo_snowflake
Laravel package: https://github.com/appsfortableau/laravel-pdo-odbc

Dockerfile

If you use Docker in your local environment, here is the script to add into your dockerfile to download and install the php pdo driver.

NOTE: If you are using Docker on an ARM architecture, you can force it to a x86 architecture adding platform linux/x86_64 on the docker-compose.yml file in the container that you are installing the driver.

# Dockerfile

# Install system dependencies
RUN apt-get update && apt-get install -y \
    cmake \
    && docker-php-ext-configure pgsql -with-pgsql=/usr/local/pgsql \
    && apt-get clean && rm -rf /var/lib/apt/lists/* \
    && docker-php-ext-configure pdo_odbc --with-pdo-odbc=unixODBC,/usr \
    && docker-php-ext-install \
    pdo \
    pdo_pgsql \
    pdo_odbc \

    ENV PHP_HOME /usr/local

    # Pull the Snowflake PDO repo and install the driver
    RUN mkdir /tmp/pdo_snowflake && \
        git clone https://github.com/snowflakedb/pdo_snowflake.git /tmp/pdo_snowflake
    RUN cd /tmp/pdo_snowflake && \
        bash ./scripts/build_pdo_snowflake.sh && \
        cp modules/pdo_snowflake.so /usr/local/lib/php/extensions/no-debug-non-zts-*/ && \
        cp ./libsnowflakeclient/cacert.pem /usr/local/etc/php/cacert.pem
    RUN echo "extension=pdo_snowflake.so" > /usr/local/etc/php/conf.d/pdo_snowflake.ini && \
        echo "pdo_snowflake.cacert=/usr/local/etc/php/cacert.pem" >> /usr/local/etc/php/conf.d/pdo_snowflake.ini

Logging changes in Laravel using Traits

Emanuel Navarro — Thu, 29 Feb 2024 02:46:40 +0000

In this post I'll show you how to track all the changes (created, updated and deleted) from any model that you want using laravel traits.

In Laravel, traits are a powerful tool for reusing code across multiple classes. They provide a way to share methods among classes without using traditional inheritance. Traits are like "partial classes" or mixins, allowing you to group related functionality together and avoid repetitive code.

First, let's create the migration for the table to record all the changes:

php artisan make:migration create_changelogs_table

// app/database/migrations/create_changelogs_table.php

public function up(): void
{
    Schema::create('changelogs', function (Blueprint $table) {
        $table->id();
        $table->unsignedBigInteger('user_id')->nullable();
        $table->string('action');
        $table->string('model', 100);
        $table->json('old_values')->nullable();
        $table->json('new_values')->nullable();
        $table->json('changed_values')->nullable();
        $table->timestamps();
        $table->foreign('user_id')->references('id')->on('users')
            ->onDelete('NO ACTION')->onUpdate('NO ACTION');
    });
}

public function down(): void    
{
    Schema:dropIfExists('changelogs');
}

Then, we'll use the models events to create the custom Observable trait:

// app/Traits/ObservableTrait.php

<?php

namespace App\Traits;

use App\Models\ChangeLog;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Auth;

trait ObservableTrait
{
    // The bootObservable() will be called on model instantiation automatically

    public static function bootObservable()
    {
        static::saved(function (Model $model) {
            if($model->wasRecentlyCreated) {
                static::logChange($model, 'CREATED');
            } else {
                if(! $model->getChanges()) {
                    return;
                }
                static::logChange($model, 'UPDATED');
            }
        });

        static::deleted(function (Model $model) {
            static::logChange($model, 'DELETED');
        });
    }

    public static function logChange(Model $model, string $action) 
    {
        ChangeLog::create([
            'user_id' => Auth::check() ? Auth::user()->id : null,
            'action'  => $action,
            'model'   => $model::class,
            'old_values' => $action !== 'CREATED' ? $model->getOriginal() : null,
            'new_values' => $action !== 'DELETED' ? $model->getAttributes() : null,
            'changed_values' =? $action == 'UPDATED' ? $model->getChanges() : null,
        ]);
    }
}

Now you can use this trait in any model, just include the namespace and import it inside the model:

// app/Models/User.php

<?php

namespace App\Models;

use App\Traits\ObservableTrait;

class User extends Authenticatable
{
    use ObservableTrait;
    //
}

Every time you create, update or delete the model it will create a changelog record.

Note: If you want to log changes for specific cases, for example when a user log in, just use the logChange method in the controller:
// app/Http/Controllers/Auth/LoginController.php

public function authenticated(Request $request, User $user){
    self::logChange($user, 'LOGGED');
}

I hope you find this post helpful.