DEV Community: aduramimo

HNG 11 - Background and Goals

aduramimo — Fri, 28 Jun 2024 11:42:26 +0000

I've been a software developer for the better part of 7 years and HNG has always been a valuable companion in re-inforcing the new concepts I learned to a professional level. I have a continuous learner's mindset and so I have consistently joined HNG editions since 2019 (only missing the last two editions due to work commitments).

I have had to work on various difficult tasks in my career as a backend developer but I think one which stood out for me was when I had to use eager loading for the first time nearly 2 years ago. I have heard the concept before but I simply didn't fully appreciate its use till I was tasked with retrieving huge amounts of customer Information (> 1 million), processing them, sending out email blasts and also updating the database upon completion. All this in a very short window (5-6 hours) and with no lag in performance or database timeouts.

I approached this by trying to understand the why: why exactly do we use it, after this I proceeded to use an ORM (Eloquent) to get the job done. This was because using such package allows me leverage on the hard work done by several intelligent developers and I wouldn’t waste time trying to reinvent the wheel. Also, concepts like queues, jobs events, etc, were also incorporated.

I just switched languages from PHP to Javascript (Node JS) for work and so I hope to strengthen my knowlegde and getting my hands dirty in HNG 11. I hope to understand specifically Typescript and Nest JS over the course of the internship.

A little about HNG: its a completely free remote learning platform where tech professionals and enthusiasts alike can learn everything there is to learn in tech, build cool projects and also get job-ready. If you are experienced developer like me, you can use it to brush your knowledge on what you already know and pick up new skills along the way. You can check them out here: https://hng.tech/internship

How to set up a continous deployment pipeline for a Laravel App on a Linux server

aduramimo — Mon, 01 Jan 2024 20:11:08 +0000

We have seen examples of how to automate application builds by dockerising and deploying them on azure cloud servers. This continous deployment which is being managed by Azure removes the burden of deployment from developers who can focus on the application itself.

In some cases, we have provisioned Linux servers for ourselves and wish to have full control of the CI/CD process (and to stop using the old FTP upload method).

For this tutorial, we have a Linux Ubuntu server (> 18.0) from Azure and have a laravel app already pushed to github which we wish to run on the server. See the latter part of deploying laravel apps on a Linux server after completing this tutorial to set up the deployed laravel app on the server.

1.cd to the desired directory you wish the app on your server and clone the app from Github:

cd /var/www/html
git clone https://github.com/dreywandowski/my-repo.git
cd my-repo

2.Next, we need to create an SSH key-pair that would be used to access your server from Github:

ssh-keygen -t ed25519 -C "your_email@email.com"

Please note that the email to use is the one used to sign in to your Github.
Press "Enter" to save to the default location. Also press "Enter" when asked for a paraphrase.

3.The next step is to start this key in background and add it

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

4.Test the ssh connection to github:

ssh -T git@github.com

You should see something like this, which confirms that you have successfully added the ssh key to your server:

5.We need to copy the contents of this ssh key and add them to Github:

cat ~/.ssh/id_ed25519.pub

Go to your Github > Settings > SSH and GGP keys > New SSH Key
Give it any title you wish and paste the content under the "key" column and save.

6.Next, we need to create a workflow file to sync changes from the repository to our server.
Navigate to the repository > Actions > Laravel >configure

7.Click "Commit changes", navigate to the directory on your server and pull the changes:

You will see a .github folder in your directory where there exists a laravel.yaml file, open it up and edit thus:

Commit and push this to master. The deployment will fail because we are yet to define what HOST, USERNAME, PASSWORD all mean. Navigate to Settings > Actions secrets and variables > Repository secrets > New Repository secret.

Define HOST, USERNAME, and PASSWORD in turn, where HOST is your server Public IP, Username and password are your server login credentials.

Now, any push we make to the master branch from our IDE will be directly deployed on the server. You can check the workflow status under Actions.

Deploying Dockerised Laravel Applications on Azure

aduramimo — Mon, 23 Oct 2023 11:57:39 +0000

So we have been able to containerize a Laravel app in this tutorial and everything is fine and dandy. How do we go about actually deploying it though, and making the image get live updates and essentially "rebuild" itself?

We need 3 things: a Github account which would serve as source control, a Circle CI account to act as middleware to help with our workflows and finally, a Microsoft Azure account with an active subscription. We would be deploying the app on the infrastructure provided.

1.On your Azure portal, click on Create a resource and search for "azure registry". Click on Create.

2.Fill in your desired name and the Review and Create

3.Once done, navigate to "Access Keys" , make sure "Admin User" is checked on Enabled. Copy your username and password as well. We will be needing it.

4.Build the application locally like before. There is a slight difference though. We would append the name of the docker build command thus:

docker login -u {user} -p {password} adura.azurecr.io

docker build -t adura.azurecr.io.azurecr.io/docker-repo .

Here, we login from our code editor to the Azure registry. We then build the Docker image, using the registry name as the leading tag together with the desired image name. This would allow the Docker daemon to tag it to the appropriate Azure registry.

5.You can also run it locally to confirm its running:

docker run -p 8000:80 adura.azurecr.io.azurecr.io/docker-repo

We will now push the code to the Azure registry:

docker push adura.azurecr.io/docker-repo

Verify that it exists as a repository in the registry:

6.Next, we will need to create an Azure Web app for the container. Go to Create Resource and search for "web app for containers"

Give it a relevant name and navigate to the "Docker" tab. Select "Azure Container Registry" as your image source and wait for the dropdown to populate. Select the repo we pushed and Review + Create

Navigate to the URL generated to see your application:

7.We will now look towards continious intergration, i.e. making changes to the app and refreshing the docker build on Azure automatically. Navigate to Deployment Center , turn "Continous Deployment" to ON. Any changes to the docker repo will trigger a fresh build of the image for our application.

8.Next, push your code to Github, sign-in to Circle CI and then link your Github's repo to identify your latest project. Click on "Set Up Project". Click on the prompt that says you will use the configuration in your project:

Next, click on Project Settings > Environment Variables, fill in the user credentials of your Azure registry so as to hook into the Azure registry, DOCKER_USERNAME and DOCKER_PASS.

9.We now need to write the circle CI config file in our project.
Create a folder with the name .circleci in the root of your project, create a file config.yml and paste the following sample workflow:

version: 2.1
orbs:
  docker: circleci/docker@2.1.2
jobs:
  build-and-test:
    description: Setup laravel application
    docker:
      # Specify the version desired
      - image: cimg/php:8.0-browsers

    steps:
      - checkout

      - run:
          name: "Prepare environment"
          command: |
            sudo apt update
      # Download and cache dependencies
      - restore_cache:
          keys:
            # "composer.lock" can be used if it is committed to the repo
            - v1-dependencies-{{ checksum "composer.json" }}
            # fallback to using the latest cache if no exact match is found
            - v1-dependencies-

      - run:
          name: "Install dependencies"
          command: composer install -n --prefer-dist

      - save_cache:
          key: v1-dependencies-{{ checksum "composer.json" }}
          paths:
            - ./vendor

      - run:
          name: "Create .env file and generate app key"
          command: |
            mv .env.example .env
            php artisan key:generate

      - run:
          name: "Run tests"
          command: php vendor/bin/phpunit

  build-docker-image:
    executor:
      name: docker/docker
      tag: "3.6"
    steps:
      - checkout
      - docker/install-docker-tools
      - setup_remote_docker:
          version: 20.10.14
          docker_layer_caching: true
      - run:
          name: "Build and push Docker image"
          command: |
            docker build -t adura.azurecr.io/docker-repo:latest .
            docker login -u $DOCKER_USER -p $DOCKER_PASS adura.azurecr.io/docker-repo:latest
            docker push adura.azurecr.io/docker-repo:latest

workflows:
  test-and-deploy:
    jobs:
      - build-and-test
      - build-docker-image:
          requires:
            - build-and-test

10.Finally we push to Github and check our Circle CI dashboard. The progress will show and the setup will be completed.

How to Dockerize Laravel Applications

aduramimo — Mon, 28 Aug 2023 18:38:24 +0000

One of the most interesting (and sometimes frustrating) aspects of building software lies in deploying them. There are many dependencies, libraries and infrastructure to take note. Docker seeks to provide a uniform and consistent platform on which to deploy applications that would run anywhere with no issues, effectively solving the "it works on my machine" war between developers and testers. It does this by providing "containers", which are isolated shells housing everything an application needs to run, and "images", which is a snapshot of the application itself.

You need to have Docker Desktop installed and running on your computer to proceed. (Docker Desktop)

Let us now build a simple laravel app and make it run in Docker, or "dockerise" it.

1.Install a new Laravel app thus:

composer create-project laravel/laravel:^8.0 docker-app

cd docker-app

php artisan serve

2.Create a new folder in the root of the application titled: "apache", create a file inside it: 000-default.conf and paste the following code:

<VirtualHost *:80>

  ServerAdmin webmaster@localhost
  DocumentRoot /var/www/html/public/

  <Directory /var/www/html>
    AllowOverride All
    Require all granted
  </Directory>

  ErrorLog ${APACHE_LOG_DIR}/error.log
  CustomLog ${APACHE_LOG_DIR}/access.log combined

</VirtualHost>

This means we are using Apache as our webserver and setting up the virtual host configuration to make it work (What are Virtual Hosts?)

3.Create a folder in the root of the application, titled supervisor, and then create a file called docker-worker.conf. This will serve to always run queues without us manually doing so. Paste the following code in it:

[program:laravel-worker]
process_name=%(program_name)s_%(process_num)02d
command=php /var/www/html/artisan queue:work --daemon --tries=3
autostart=true
autorestart=true
numprocs=4
stdout_logfile=/var/www/html/storage/logs/worker.log
redirect_stderr=true

4.Create another file in the root of the application, titled "start.sh". We would input our cronjobs in this file so that the container will run any cron commands, be it Laravel schedules or just plain old cronjobs. Paste the following code:

#!/bin/bash

# Navigate to the project directory
cd /var/www/html


# Run the desired commands or scripts
CRON_COMMAND="* * * * * /usr/local/bin/php -q -f /var/www/html/artisan schedule:run --no-ansi >> /var/log/cron.log 2>&1"

# Add the cron job command to the crontab
echo "$CRON_COMMAND" | crontab -

# Any other commands or scripts you want to run as part of the cron job

# Exit with a success status code
exit 0

5.In the root of the application, create a Dockerfile (with no extension, and paste the following commands:

# Base image
FROM php:7.4-apache


# Install required dependencies
RUN apt-get update && \
    apt-get install -y --fix-missing \
    libzip-dev \
    zip \
    unzip \
    nano \
    curl \
    cron \
    dos2unix

# Install the required version of Composer
RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer

#Install MySQL driver
RUN docker-php-ext-install pdo_mysql

# Install Supervisor
RUN apt-get install -y supervisor

# Create a Supervisor configuration directory
RUN mkdir -p /etc/supervisor/conf.d

# Copy Supervisor configuration file into the container directory
COPY supervisor/docker-worker.conf /etc/supervisor/conf.d/docker-worker.conf

# Set working directory
WORKDIR /var/www/html

# Copy app files
COPY . /var/www/html   
COPY apache/000-default.conf /etc/apache2/sites-available/000-default.conf

# Adjust PHP memory_limit
RUN echo "memory_limit=512M" > /usr/local/etc/php/conf.d/memory.ini


# Install dependencies
RUN composer install --prefer-dist --no-interaction

# Set file permissions
RUN chown -R www-data:www-data /var/www/html/storage /var/www/html/bootstrap/cache 
RUN chmod -R 775 /var/www/html/storage /var/www/html/bootstrap/cache 

# Enable Apache modules
RUN a2enmod rewrite

# Configure cron
RUN touch /var/log/cron.log

# Script file copied into container.
COPY ./start.sh /start.sh

# convert to UNIX style
RUN dos2unix /start.sh

# Giving executable permission to script file.
RUN chmod +x /start.sh

# Expose port 80
EXPOSE 80

# Do house-keeping
RUN php artisan config:cache && \
    php artisan route:cache 

# Start Apache server, queue worker and cron service
CMD ["/bin/bash", "-c", "service apache2 start && /start.sh && cron && supervisord -n"]

The commands are basically self-explanatory, however I would explain a few: the base-image directive says what version of PHP we wish to use for the project (head to PHP Tags) for more, # Install required dependencies for essential tools we would need to run the container, then we install composer, and also install a driver to allow MySQL run.

The last command, the most important one, starts the webserver, executes the script file that activates our cron service, and also starts the laravel queue daemon. This is very handy incase you are building an application with jobs and queues and need the daemon to be running continuously while processing jobs.

6.We have now created all that is needed for the docker image. Build the image with the following command and wait for the image to bundle: docker build -t docker-app . Once done, run the container: docker run -p 8000:80 docker-app, navigate to 127.0.0.1:8000 and see your laravel app running in the container:

If you have any Laravel schedule activated, you would see the results in your terminal:

7.You can debug the app container by logging on the terminal of the container provisioned by your Docker Desktop application and clicking the icon highlighted

If you prefer CLI management, you can also copy the container name or id provided and logon with the command docker exec -it <container_id_or_name> /bin/bash. This would open up the terminal of your docker container and debug effectively.

8.Once everything is set up and running fine we can be sure that this application would run anywhere and can push it to Github or whatever code versioning tool employed by your organization, so that your DevOps engineers would pick it up and set up an appropriate pipeline for a continuous deployment.

9.You can stop the container with the following command: docker stop <container_name_or_id>. If your intention is to stop and remove the container then use the command: docker rm <container_name_or_id>

How to perform very large Insert/Update operations in Laravel efficiently

aduramimo — Fri, 19 May 2023 17:55:22 +0000

Writing backend laravel logic means having to wrestle with database manipulation problems from time to time, and if you have ever been in a situation where you have very large records to insert or update (say 15,000), especially when writing cron jobs that crawl applications for very large information and tries to send back reports for business intelligence purposes, it might shock you to note that these operations may take anywhere between 10 minutes to 1 hour if care is not taken to optimize such code, depending on the various timeout settings on your server.

Writing a database insert for each record in an array with the following code might seem okay if done on a local environment or even on a server with few records to worry about:

                  foreach ($rows as $record) {        
                            DB::table('my_table')->insert([
                            'clientid' => $record['id'],
                            'full_name' =>$record['full_name']),
                            'status' => $record['status']),
                            'created' => now(),
                            ]);
                                          }

This is not efficient however, and might result in unpleasant scenarios such as memory leaks, abrupt SQL locks and so on, when such logic is employed for large datasets.

Some try to overcome this challenge by writing special queued jobs to do this in the background, however there is a better way to get around this issue by simple array manipulations as outlined below:

Assuming you have an array of 25000 records stored in a variable $arrayData.
Define another empty array $insertion_data = array();
Loop through the $arrayData while assigning your database values against each key in $arrayData and push each item into the $insertion_data array :

            $insertion_data = array();

            foreach ($arrayData as $arr){
                $new_data = [
                    'data_requested_at' =>  date("Y-m-d H:i:s", 
                     strtotime($arr['data_requested_at'])),
                    'response_code' => $arr['response_code'],
                    'status' => $arr['status'],
                    'created_at'  => date('Y-m-d H:i:s'),
                    'updated_at'  => date('Y-m-d H:i:s')
                ];

                $insertion_data[] = $new_data;
                            }

4.Grab your final insertion data to a Laravel collection
$insertion_data = collect($insertion_data);

5.Leverage the Eloquent chunk method to have a pool of records you want to insert/update per time. You may start with 500 and then increase it according to requirements. Now loop through this new Collection and perform your database insertion. Don't forget to implement the try-catch technique to investigate database errors.

         $data_to_insert = $insertion_data->chunk(500);
         foreach ($data_to_insert as $key => $data)
         {
             try{
             DB::table('my_target_table')->insert($data 
                       ->toArray());
             }
             catch(\Illuminate\Database\QueryException $e){
                 $error = $e->getMessage();
                 echo $error;
             }
         }

How to deploy a Node/React App on a Linux server

aduramimo — Fri, 30 Sep 2022 15:50:43 +0000

When I started learning Node JS few weeks ago, the very first question that came to my mind was: hosting and deployment.

There are several solutions online (Netlify, Heroku etc) but this is for developers who will at some point find themselves in situations where they have to deploy on managed servers.

So let's dive in with the following steps:
1.Provision a Linux Ubuntu server. Check out how to get one from Azure in this article

2.SSH into the machine and install node and npm globally:

sudo apt update

curl -sL https://deb.nodesource.com/setup_18.x | sudo -E bash -

sudo apt install nodejs

Verify your node and npm installations:

node -v

npm -v

3.cd into /var/www/html, create a folder where your node files will sit:

sudo mkdir node_project

Ensure to grant your user ownership over the folder so you can be able to make file edits:

sudo chown -R $USER:www-data node_project
sudo chmod -R 775 node_project

Create a blank index.js file, which will be the entry point of the application.

sudo nano index.js

4.Initialize and install the various dependencies needed for a Node project to run, i.e. the node_modules folder:

npm init

The wizard will bring up several questions in the terminal, fill in some defaults and press the space key for the ones you have no answer for:

Type ok to confirm.

5.Edit the index.js file and bring in some quick-fire essential code to start up our node server:

6.Install dependencies needed in the node_modules folder. We only need express installed for this tutorial:

npm install express

Test your project and see if its running:

node index.js

7.The server is now running on the port specified (4000), once you go to http://(your-domain):4000 you should see the output. However, this is only good enough for development/staging. We do not want users having to access our application and having to type in port names, for SEO purposes and for the sake of branding. The solution is to make the Apache web server serve as reverse-proxy for the application so we would be able to type http://(your-domain) and still get to the node application.

Create a new virtual host file for our new app (Further reading: Host several websites on a Linux server using Virtual Hosts)

sudo nano /etc/apache2/sites-available/node-project.conf

Add the following lines:

<VirtualHost *:80>
    ServerName www.node-project.com
    DocumentRoot /var/www/html/node_project

    ProxyRequests Off
    ProxyPreserveHost On
    ProxyVia Full

    <Proxy *>
        Require all granted
    </Proxy>

    ProxyPass / http://localhost:4000/
    ProxyPassReverse / http://localhost:4000/
</VirtualHost>

Save and close the file. Enable the config file:

sudo a2ensite node-project.conf

Enable proxy modules:

sudo a2enmod proxy proxy_http rewrite headers expires

Disable the default virtual host config file:

sudo a2dissite 000-default

Restart Apache:

sudo service apache2 restart

Navigating to your website will bring you to your Node app.

8.Node applications typically shut down after you manually stop the server, after SSH connection time-out or server restarts. Prevent this by making it a default start-up service to always start up in the event of any of the above-mentioned factors.

Create a systemd service file by the following command:

sudo nano /lib/systemd/system/node-project.service

Copy and paste the following code:

[Unit]
Description=Node.js Application
After=syslog.target network.target

[Service]
Type=simple
User=Aduramimo
WorkingDirectory=/var/www/html/node_project
Environment=NODE_ENV=production
ExecStart=/usr/bin/node index.js

Restart=always

[Install]
WantedBy=multi-user.target

The After keyword signifies that this service should fire after essential Linux kernel files have loaded properly, User will be your username to the linux server. We do not use root for security reasons.
WorkingDirectory is the absolute path to our project folder, Environment signifies where in the app the service should target (this is also the same value in your NODE_ENV variable in the .env file), while ExecStart is the actual process to be fired. We call the node daemon where it is been installed on the entry point already defined in step 4 above.

Save and exit.

9.Run the following code in turn:

sudo systemctl daemon-reload
sudo systemctl start node-project
sudo systemctl enable node-project
sudo systemctl status node-project

You should get the following interface which means that the service is running successfully:

Please note that this will assume your default Node Terminal from now on. Any changes made to your server will be effected by the commands shown above and status also shown there.

Automatically refresh your Node server to watch for file changes in your entry point (index.js) by installing Nodemon with

npm install nodemon

in your project directory and replace /usr/bin/node with /usr/bin/nodemon in the ExecStart command of the service created.

10.We are done deploying the Node application. Some Linux distros however, like CentOS or Redhat, might prevent the service file running due to some security feature known as SELinux (Security-Enhanced Linux) that is enabled by default. If this applies to you, follow the following steps to troubleshoot and resolve:

Check the status of SELinux :

sudo sestatus

It will be something like this:

Now we need to temporarily disable it by setting the status to permissive. This is like disabling SELinux but also logs critical error messages for us to troubleshoot the root cause.

sudo nano /etc/sysconfig/selinux

Changed enforcing to permissive.

Restart the server:

 sudo reboot

and then check the status:

 sudo sestatus

It should be on permissive.

The Node service file will be running now, however, our work is not done, since it is strongly advised not to turn off SELinux or stay on permissive mode.

Look out for the most recent error messages logged by the OS via

sudo nano /var/log/messages

you should see something of the following nature in the console:

Oct  5 09:07:34 Aduramimo setroubleshoot[1811]: SELinux is preventing 
/usr/bin/node from using the execmem access on a process. 

For complete SELinux messages run: sealert -l e5cb75a6-c29c-4461-b716-d1a376e$

Follow the recommendation in the result. Note that you might get a query error of ID not found if you try to run the sealert command above. To get the full ID, run

sudo sealert -l '*' | grep ‘<‘id_from messages’>

Follow the action point suggested. A typical fix will be something like:

## sudo ausearch -c 'npm' --raw | audit2allow -M my-npm
## sudo semodule -X 300 -i my-npm.pp

We will now re-enable selinux to the enforced state by editing the config file and changing permissive to enforcing and reboot the server.

sudo nano /etc/sysconfig/selinux

sudo reboot

To deploy a React project:
The above steps applies for react applications, except for step 7, where we change the React service file slightly:

[Unit]
Description=React.js Application
After=syslog.target network.target

[Service]
Type=simple
User=Aduramimo
WorkingDirectory=/var/www/html/react_project
Environment=NODE_ENV=production
ExecStart=/usr/bin/npm start

Restart=always

[Install]
WantedBy=multi-user.target

The major difference is in the ExecStart command which we adjust to reflect how a react app normally starts up.

If you installed Node and NPM via NVM on your server, the above might not work. You might try look at the following alternative steps if the React app fails to startup:

[Unit]
Description=React.js Application
After=syslog.target network.target

[Service]
Type=simple
User=Aduramimo
WorkingDirectory=/var/www/html/react_project
Environment=NODE_ENV=production
ExecStart=/home/{USER}/react.sh

Restart=always

[Install]
WantedBy=multi-user.target

Where {USER} is your Linux server.

Navigate to your user's root directory and follow the following:

sudo nano react.sh

Copy the following code:

#!/bin/bash
. /home/{USER}/.nvm/nvm.sh
npm start

Then finally

chmod +x /home/{USER}/react.sh

Restart the systemd daemon and start the service.

You can also try the following method:

Replace the value of ExecStart in the systemd service file to

/home/{USER}/.nvm/nvm-exec npm start

For a Node application, Replace the value of ExecStart in the systemd service file to

/home/{USER}/.nvm/nvm-exec node /var/www/html/index.js

How to setup cronjobs for a Laravel project

aduramimo — Mon, 06 Jun 2022 17:23:58 +0000

Tasks like sending email reminders, checking for inactive users, running daily backups, etc., are usually repetitive and as such developers/sysadmins need to leverage the power of cron to automate such tasks.

This tutorial will show how to automate tasks in a laravel application (known as scheduling).

In this tutorial, I will be writing a cron job which deletes expired personal access tokens generated by sanctum for authentication from the database after a determined number of days.

Step 1: On the command line in the root directory of your Laravel application, run the following command on the console to create a new command:
php artisan make:command DeleteExpiredTokens --command=tokens:cron

Step 2: Open the newly-created Command file and edit the logic as follows:
(Directory: app/Console/Commands/DeleteExpiredTokens.php)


namespace App\Console\Commands;

use Illuminate\Support\Facades\DB;
use Carbon\Carbon;
use Illuminate\Console\Command;
use Laravel\Sanctum\Sanctum;
use App\Models\Tokens;
use DateTime;

class DeleteExpiredTokens extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'tokens:cron';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Command description';

    /**
     * Create a new command instance.
     *
     * @return void
     */
    public function __construct()
    {
        parent::__construct();
    }

    /**
     * Execute the console command.
     *
     * @return int
     */
    public function handle()
    {
// Get the current time
$now = Carbon::now();

// Set the time limit for deleting tokens (2 days for this tutorial)
$limit = $now->subDays(2);

// Delete all personal access tokens that were created before the limit
try{
    $delete = DB::table('personal_access_tokens')
    ->where('created_at', '<', $limit)
    ->delete();
}
catch (\Illuminate\Database\QueryException $e)
{
    echo "error deleting!! ".$e;
}

echo "Deleted OK for today... ".date('Y-m-d')." , items deleted == ".$delete."<br>";
    }
}

The handle() function is the most important part of the command. Here, you can write whatever database, email sending or database backup logic you want.

Step 3: Register the command on the Kernel.php file to handle frequency and when you want the command to run.

(Directory: app/Console/Kernel.php)

<?php

namespace App\Console;

use Illuminate\Console\Scheduling\Schedule;
use Illuminate\Foundation\Console\Kernel as ConsoleKernel;

class Kernel extends ConsoleKernel
{
    /**
     * The Artisan commands provided by your application.
     *
     * @var array
     */
    protected $commands = [
        //
        Commands\DeleteExpiredTokens::class,
    ];

    /**
     * Define the application's command schedule.
     *
     * @param  \Illuminate\Console\Scheduling\Schedule  $schedule
     * @return void
     */
    protected function schedule(Schedule $schedule)
    {
        $schedule->command('tokens:cron')
                 ->timezone('Africa/Lagos')
                 //->everyMinute()
                // ->everySixHours()
                 ->dailyAt('04:00');
                 ->appendOutputTo('cron.txt');


    }

    /**
     * Register the commands for the application.
     *
     * @return void
     */
    protected function commands()
    {
        $this->load(__DIR__.'/Commands');

        require base_path('routes/console.php');
    }
}

In the schedule method, Laravel offers a variety of options for us to define when we want the command to run. Simply define the one that suits your needs. You also can define as many commands as you want and the laravel task scheduler will run all in turn and according to your define timings.
the appendOutputTo() method creates a file that outputs whatever message you returned in the Command file created up in Step 1. This gives instant insight on the whether the cron job is doing what we want.

Further insight is provided in the official documentation

Step 4: In order for our schedules to work, we need to add a single cron entry on the Linux server that will take care of all our schedules from the Laravel application.

Type the following commands on the SSH terminal:
a. sudo crontab -e. If this is the first time you are configuring cron on the server, it will prompt for the editor to use.

b. * * * * * /usr/bin/php /var/www/html/your_laravel_app/artisan schedule:run > /tmp/cron_log.txt
This is a directive that runs the cron daemon every minute, checks every schedule you defined under Kernel.php, executes it and dump a log file in the tmp folder for analysis.
Cron will not give information whether or not its commands run successfully, so the only way to troubleshoot is by having a log file.

c. Restart the service by typing:
sudo service cron reload

Step 5: You can optionally test-run the schedule locally to simulate how it will run on the server by running:
php artisan schedule:work

How to host several websites on a single Linux server

aduramimo — Tue, 08 Feb 2022 17:59:40 +0000

Most of the time, we deploy web applications on popular hosting sites like Hostinger, whogohost, etc., who give us spaces to host our application files (known as shared hosting). Depending on our subscription model however, we may find that we are limited in what we can actually do by way of SSH access, number of cronjobs, database limits and so on.

We can go the way of getting a dedicated cloud hosting from AWS, Google or Azure, where we can provision virtual Linux machines
on which we can deploy our applications while maintaining full control. I explained how to do that with Azure here.

Of course, it is normal that we might have several websites/applications with different domain names all consolidated on the same server instance, this means we can self-host as many websites as we have on the same server as long as space allows for it. This is possible by the Virtual Hosting feature of Apache.

Steps:

1.SSH to the Linux server using Putty

2.We need to create a separate directory in the web directory that Apache uses to serve web pages (/var/www/html). Create a new folder thus: /var/www/html/new-website. This is the folder all requests to our website will be routed to. You can upload all your website files in this directory.

3.We want to copy and modify the default web config file in the apache config directory. Copy the following code:

sudo cd /etc/apache2/sites-available

Copy the default web config file (000-default.conf) and paste with a name for our new website we want to add.

sudo cp 000-default.conf new-website.com.conf

4.We will now edit the newly-copied file:

sudo nano new-website.com.conf

5.Once the file opens, you should see something like this, with some lines commented out:

Edit the file by coming down to the ServerName, uncomment it by removing the # character, remove www.example.com and type the address of our website, new-website.com.
You can also set alias for the website to capture different wildcards by adding ServerAlias wwww.my-website.com immediately after the ServerName directive, you can add as many as you want.
Come down to DocumentRoot, remove /var/www/html, replace with the directory that you have created for the new site under (/var/www/html), something like /var/www/html/new-website.. this is the directory that visitors will be re-directed to whenever they type in the web address.
Your changes should look like this:

. Save and exit.

6.After doing this we need to tell Apache to activate this particular setting, only then the configuration can be complete:

sudo a2ensite new-website.com.conf

7.Restart Apache server:

sudo service apache2 restart

8.We have taken care of the Server end, we need to point the DNS records for our domain to the Linux server IP address in case we have not done so before.
Navigate to the DNS settings of your domain, create a new A record with the value of the server's IP address.

Wait for 1-2 hours to propagate. All done. Repeat the entire process for as many sites we wish to configure on the server.

How to deploy a Laravel App on an Azure Ubuntu server

aduramimo — Sun, 23 Jan 2022 08:52:24 +0000

Okay so this post is not a tutorial in the full sense of it, rather than to show/demonstrate the steps I took to deploy my Laravel app on a dedicated Linux server on Azure. I've been deploying Laravel apps on shared hosting servers although you will agree with me that some shared hosting environments comes with its own problems of not having SSH access to run some artisan commands and having to manually upload changes via FTP, which is prone to errors. I wrote this as a personal reference but I hope someone finds this useful.

I created a free account on portal.azure.com which gives you free access to about $200 credit and avails you to a host of the various services available on Azure's cloud offerings.
Create a resource, choose Ubuntu 20.04 virtual machine. Place it in your desired resource group. Choose the region desired and name the machine appropriately.
Size: since this is a demo app, it is critical we go with the most minimal size as possible to save costs and also that will be sufficiently enough to accommodate our application size. In my case I went with the Standard b1s (1 virtual CPU and 1GB memory) that translates to 8 USD monthly. This is more than enough to run a development Laravel application.

4.Move to the next step "Administrator account" for Authentication type, select password, set your username and password. Check HTTP and SSH in the inbound public rules. This ensures that our application is visible to the public and also means we can SSH to the server using the admin details created above. Once done let's create the virtual machine.

5.Once you are done, click on Create and wait for Azure to provision the machine. We have created our machine, so how do we start uploading files? Click on "Go to resource" where you will see some vital information:

"Public IP" is the IP assigned to the server. This is what you give people to access your website. It is also what you use to login to the server via SSH. You can choose a DNS like "example.azureapp.com" under the DNS name though like shown in the screenshot.

6.Open Putty on your Windows environment and enter the Public IP assigned to us in Step 5 above and choose port 22. This will open up a shell command to logon to Linux environment. When prompted, login with the Admin Username and password created in step 4. We are now in the Linux environment.

7.We want to install Apache, MySQL and PHP in turn on the server.
Let us update the package list to ensure we are installing the latest packages on the server:

sudo apt-get update

Install Apache:

sudo apt-get install apache2

You can test the installation of the Apache by browsing to your site's public IP. A welcome page will be displayed.

Install MySQL:

 sudo apt-get install mysql-server

Continue to configure the mysql server by continuing with the command

sudo mysql_secure_installation

You will be prompted configure passsword for the root user. Once you are done you can test your installation by logging in

sudo mysql -u root -p

Install PHP:

sudo apt-get install php libapache2-mod-php php-mysql php-curl php-gd php-json php-zip

Once done you need to restart the apache server:

sudo service apache2 restart

Install PHPMyadmin:

sudo apt-get install phpmyadmin

Follow the steps and confirm your installation by navigating to
your_site_public_ip/phpmyadmin

8.We have installed the LAMP stack on our server. Now is the time to download our files to the server. We have two options: Git deployment and local FTP upload.

Git: on the SSH, navigate to the web directory of the linux server (/var/www/html) by using the following:

cd /var/www/html

This is the root directory for our website.

I assume by now you have pushed your latest laravel updates to a git repository. Type the command

git clone your_repo_address.git

to download latest version of your app. Further updates can be gotten via

git pull

, like we normally do.
We now have our files in the environment and can start configuration. We will need to generate our application key and update composer information. But first we need to give our user access to some directories:

sudo chown -R $USER:www-data storage
sudo chown -R $USER:www-data bootstrap/cache

Then we set our directory permission:

sudo chmod -R 775 storage
sudo chmod -R 775 bootstrap/cache

Once this is done we can create our own env file by

cp .env.example .env

Edit your env variables by following the command

 sudo nano .env

and use CTRL+X to exit when done.

Then

 artisan key:generate

FTP: Open up FileZilla, create a new site setting as shown below.. Host is the site's Public IP, enter your username and password, if everything is ok you will be logged in to the root directory. You can change that and navigate to /var/www/html.
Here is where you can upload your Laravel project on to the server.

9.We have now deployed our app to the server. There is one more snag though. You may observe that while trying to navigate to the site you may be getting a 500 internal server error. This is because Laravel's root directory is not in the root /var/www/html like a regular PHP project but under the public folder.
We need to configure some Apache files to re-route our requests to the public folder: php sudo nano /etc/apache2/sites-available/000-default.conf.
In the file you will see something like

VirtualHosts *80

Immediately under this come down and type:

<Directory /var/www/{your-directory}>
    Options Indexes FollowSymLinks MultiViews
    AllowOverride All
    Require all granted
</Directory>

Modify the .htaccess file under public to reflect the following changes:

<IfModule mod_rewrite.c>
    <IfModule mod_negotiation.c>
        Options -MultiViews -Indexes
    </IfModule>

    RewriteEngine On

    # Handle Authorization Header
    RewriteCond %{HTTP:Authorization} .
    RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]

    # Redirect Trailing Slashes If Not A Folder...
    RewriteCond %{REQUEST_FILENAME} !-d
    RewriteCond %{REQUEST_URI} (.+)/$
    RewriteRule ^ %1 [L,R=301]

    # Send Requests To Front Controller...
    RewriteCond %{REQUEST_FILENAME} !-d
    RewriteCond %{REQUEST_FILENAME} !-f
    RewriteRule ^ index.php [L]


</IfModule>
  <IfModule mod_rewrite.c>
    RewriteEngine on
    RewriteCond %{REQUEST_URI} !^public
    RewriteRule ^(.*)$ public/$1 [L]
    </IfModule>

Don't forget to activate the rewrite module of your Apache server as well:

sudo nano /etc/apache2/apache2.conf

<Directory /var/www/>
Options Indexes FollowSymLinks
AllowOverride All
Require all granted
</Directory>

Finally we restart apache server using sudo service apache2 restart and we are able to view our Laravel application.

HNGi8 Goals

aduramimo — Mon, 16 Aug 2021 10:58:36 +0000

My name is Aduramimo and I am glad to be on this internship where I get to learn and re-learn relevant technologies in software development.

As an intermediate backend (PHP) developer, I seek to further buttress on my knowledge of PHP by taking on tasks that will expand my horizon and push my already-acquired knowledge to the limit.

I also would love to try my hands on Laravel projects to deepen my expertise in that regard too.

Overall, I wish to be able to finish the internship till stage 10 and be a better prospect for employments and also be more useful for my employers.

For beginners that want a quick introduction to web development, here are some curated links that would help:

LEARN FIGMA:https://www.youtube.com/watch?v=jk1T0CdLxwU
Learn Git : https://www.youtube.com/watch?v=8JJ101D3knE
Learn HTML & CSS: https://www.youtube.com/watch?v=kMT54MPz9oE
Learn PHP: https://www.youtube.com/playlist?list=PL4cUxeGkcC9gksOX3Kd9KPo-O68ncT05o

Here is the link to register for the internship: https://internship.zuri.team

Introduction to PHP

aduramimo — Tue, 28 May 2019 15:56:42 +0000

PHP, or Hypertext Processor, as it full name goes, is a new generation scripting language that has extensive use in the web community. It is an interpreted and weakly typed language that was built solely for powering the web.
PHP is employed to "talk" to the server, i.e. accept input/feedback from the front end, proccess it and then work on the result on the server side.
PHP is also used to manipulate databases, MySQL being the most popular combination.
PHP is the driving force behind Wordpress, a Content Management system that enables non-coders and coders to rapidly build their own websites without too much stress. As at 2018, Wordpress powers over 30% of the world's websites.
Popular frameworks include: Lavarel, Cake, etc.
Beginners can get started with these links: https://www.w3schools.com/php/, https://www.youtube.com/watch?v=7TF00hJI78Y