DEV Community: Hallo Rzgar

Understanding Object Storage: A Comprehensive Guide

Hallo Rzgar — Thu, 18 Apr 2024 11:55:09 +0000

In today's rapidly evolving data storage landscape, object storage has emerged as a popular choice among developers, IT professionals, and organizations. It's essential to understand what object storage is, its advantages, the available options, and when it's the ideal solution. This article aims to simplify and shed light on object storage.

Our lives depend on data storage systems. Object storage is becoming popular very fast. It's important for technology workers to understand object storage, its good points, available choices, and when it's the best option. This post explains object storage easily, showing its main traits and real uses.

What is Object Storage?

imagine yourself working with storage like unique boxes, tagged differently, instead of rigid cabinets or blocks. That's object storage - it treats data as separate "objects", bundled with metadata and identifiers. You access these objects through web calls over networks, making management effortless.
Object storage has a straightforward design - no complicated folder trees, just an expanse where each object exists independently. This simplicity allows scalability, ideal for managing massive amounts of varied, unstructured data.

Advantages of Object Storage

Scalability
Object storage grows easily, built to handle huge amounts of data—imagine exabytes—without struggling like regular file systems could under similar stress. It's fantastic for cloud storage, where demands can spike suddenly.

Durability and Availability
Data fortresses shield important info. Copies are spread across many places and gadgets. If one part breaks down, your data's still totally accessible, completely safe and sound.

Cost-Effectiveness
Can everyday materials give storage? Yes! Unlike costly disk options, object storage is economical. Low-cost items are used. Less maintenance occurs, too, which helps budgets. Overall, it's a money-saving choice.

Metadata and Customization
Object metadata enables thorough descriptions, facilitating data management. This simplifies organizing and retrieving information, permitting storage solutions customized to particular requirements.

Data Management Features
Version control, lifecycle management, and access settings are built-in tools. Together, they allow for complex data management right within the storage layer. The strategies are sophisticated and integrated.

Types of Object Storage

Object storage comes in two main flavors:

Public Cloud Object Storage:
Giants like Amazon S3, Google Cloud Storage, and Microsoft Azure Blob Storage offer scalable storage on a flexible, pay-as-you-go basis.
Private Cloud Object Storage:
Systems like OpenStack Swift and MinIO let organizations run their own object storage, keeping data in-house while still enjoying all the perks of the technology.

When and Why We Need Object Storage

Object storage shines brightly when dealing with massive amounts of unstructured data that require storage and access, yet seldom undergo modifications. This includes:

Web and Mobile Applications:
Perfect for storing all sorts of media that lights up our screens.
Data Archiving:
Ideal for keeping records and backups safe and sound over the long haul.
Big Data and Analytics:
A boon for platforms swimming in data lakes, needing scalable and flexible storage.
IoT Systems:
Capable of handling the data deluge from countless IoT devices.

Conclusion

Object storage isn't only a tool. It's an efficient helper for dealing with lots of messy data. It can grow, last long, and save money. This makes it great for many uses, especially when storing data for a long time is crucial. As more digital stuff piles up, knowing about object storage and using it well is important. Companies focused on data need it, whether working online or from their own centers.

Uploading Files to S3 or a Similar Server in Laravel

Hallo Rzgar — Sun, 02 Jul 2023 06:00:45 +0000

Introduction
Uploading files to cloud storage services like Amazon S3 is a common requirement for many Laravel applications. In this article, we'll explore how to upload files to an S3 bucket using Laravel and the AWS SDK for PHP. We'll also cover generating pre-signed URLs for accessing the uploaded files.

Prerequisites
Before we begin, make sure you have the following prerequisites in place:

1-Laravel installed on your system.
2-AWS account with S3 bucket credentials.
3-AWS SDK for PHP installed.

Step 1: Set Up the AWS SDK for PHP
To get started, install the AWS SDK for PHP in your Laravel project. Use Composer to install the SDK by running the following command in your project root directory:

composer require aws/aws-sdk-php

Step 2: Configure Laravel Environment Variables
Next, open your Laravel project's .env file and add the following environment variables
and if you have endpoint also add it:

AWS_ACCESS_KEY_ID=your-access-key-id
AWS_SECRET_ACCESS_KEY=your-secret-access-key
AWS_DEFAULT_REGION=us-east-1
AWS_BUCKET=your-s3-bucket-name
AWS_ENDPOINT=your-s3-endpoint (e.g., https://s3.your-region.amazonaws.com)
AWS_USE_PATH_STYLE_ENDPOINT=false

Step 3: Implement the File Upload Functionality
In your Laravel application, create a new controller or use an existing one. Let's assume you have a controller called S3Controller. Inside the controller, add the following code:

<?php

namespace App\Http\Controllers;

use Aws\S3\S3Client;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Storage;

class S3Controller extends Controller
{
    public function uploadFile(Request $request)
    {
        $file = $request->file('my_file');
        $bucket = env('AWS_BUCKET');
        $expiry = '+5 minutes'; // Expiration time for the URL

        $path = Storage::disk('s3')->put('folder-name', $file);

        // Set the visibility of the uploaded file to public
        Storage::disk('s3')->setVisibility($path, 'public');


        // Generate a pre-signed URL for the uploaded file
       $s3Client = new S3Client([
            'credentials' => [
                'key' => env('AWS_ACCESS_KEY_ID'),
                'secret' => env('AWS_SECRET_ACCESS_KEY'),
            ],
            'region' => 'us-east-1',
            'version' => 'latest',
            'endpoint' => env('AWS_ENDPOINT'),
            'use_path_style_endpoint' => 
            env('AWS_USE_PATH_STYLE_ENDPOINT'),
        ]);

        $command = $s3Client->getCommand('GetObject', [
            'Bucket' => $bucket,
            'Key' => $path,
        ]);


        $signedUrl = $s3Client
           ->createPresignedRequest($command, $expiry)
           ->getUri();

        return $signedUrl;
    }


// the function for get the file after upload

    public function get(Request $request)
    {

    // Specify the key and bucket name of the S3 object

   // $key must be like that get from request or database   
  //$key='foldernameA6Hlt7uyoZUpqsfIpeEpT7YRgKJ9JLGRMfnXuyRw.jpg';

        $key= $request->file('my_file');
        $bucket = env('AWS_BUCKET');
        $expiry = '1 minutes'; // Expiration time for the URL

        // Instantiate the S3 client
        $s3Client = new S3Client([
            'credentials' => [
                'key' => env('AWS_ACCESS_KEY_ID'),
                'secret' => env('AWS_SECRET_ACCESS_KEY'),
            ],
            'region' => 'us-east-1',
            'version' => 'latest',
            'endpoint' => env('AWS_ENDPOINT'),
            'use_path_style_endpoint' => 
            env('AWS_USE_PATH_STYLE_ENDPOINT'),
        ]);
        $command = $s3Client->getCommand('GetObject', [
            'Bucket' => $bucket,
            'Key' => $key,
        ]);
        $signedUrl = $s3Client
        ->createPresignedRequest($command, $expiry)
        ->getUri();

        return $signedUrl;


    }
}

Explanation:

The uploadFile method handles the file upload functionality.
It retrieves the uploaded file from the request and stores it in
the specified S3 bucket under the "folder-name" directory.
The visibility of the uploaded file is set to public, allowing
public access.
The $url variable contains the full URL of the uploaded file.
The $signedUrl variable contains a pre-signed URL for accessing
the uploaded file, valid for a specific duration.
The get method retrieves the pre-signed URL for a specific file stored in the S3 bucket. It specifies the key and bucket name of the S3 object and generates a pre-signed URL using the AWS SDK.

Conclusion:

In this article, we learned how to upload files to an S3 bucket in Laravel using the AWS SDK for PHP. We also explored how to generate pre-signed URLs for accessing the uploaded files. By following the steps outlined in this article, you can easily integrate file upload functionality with S3 or a similar server in your Laravel applications.

Leveraging Laravel WebSockets : A Practical Guide

Hallo Rzgar — Thu, 15 Jun 2023 09:38:53 +0000

In this tutorial, we will explore the concept of WebSocket API or WebSockets and its significance in real-time applications. Unlike traditional HTTP requests, WebSocket provides a two-way communication channel between the server and the client.

When using Ajax (Axios, Fetch), we can send and receive data from the server without reloading the page. However, this approach relies on one-way communication, where the server cannot send data to the client without a prior request. This limitation becomes evident in scenarios like an Ajax chat application, where we constantly need to send requests to check for new messages.

To overcome this challenge, WebSockets come into play by establishing a persistent, interactive connection session between the server and the user's webpage. This connection allows for continuous communication, resembling a phone call between the server and the browser. Once initiated, the server can send messages or objects to the webpage at any time, without the need for repetitive polling.

By leveraging WebSockets, we can create real-time applications where the server can instantly send data to the webpage. For example, consider the Facebook notification system that informs users about post likes. When someone likes a post, the server triggers a like event and promptly sends a WebSocket message notification, such as "Someone likes your post."

Through this tutorial, we will explore how to set up a Laravel WebSockets server, enabling real-time functionality using Laravel 9. Stay tuned for a step-by-step example and practical implementation.

Laravel WebSocket concept
In Laravel, the concept of WebSockets revolves around creating channels and broadcasting events to provide real-time, live-updating user interfaces. Here's a breakdown of the Laravel WebSocket concept:

1-Channel Creation: In Laravel, you can define channels in the routes/channels.php file. These channels act as communication pathways between the server and clients.

2-Broadcasting Events: To send real-time updates, you can broadcast Laravel events on specific channels. When an event is triggered, the message associated with it will be sent to all clients subscribed to that particular channel.

3-Subscribing to Channels: Clients, typically web browsers, can subscribe to specific channels to receive messages sent by the server. This allows for real-time updates without the need for constant polling.

We can install Laravel-websockets package via composer.

composer require beyondcode/laravel-websockets

The package comes with migration to save statistical information about the running WebSockets server.

php artisan vendor:publish --provider="BeyondCode\LaravelWebSockets\WebSocketsServiceProvider" --tag="migrations"

And publish the WebSocket configuration file

composer require pusher/pusher-php-server "~3.0"

We need to make our BROADCAST_DRIVER to be pusher in .env file.

BROADCAST_DRIVER=pusher

To configure Pusher for Laravel WebSockets in the config/broadcasting.php file, you can modify the configuration as follows:

        'pusher' => [
            'driver' => 'pusher',
            'key' => env('PUSHER_APP_KEY'),
            'secret' => env('PUSHER_APP_SECRET'),
            'app_id' => env('PUSHER_APP_ID'),
            'options' => [
                'cluster' => env('PUSHER_APP_CLUSTER'),
                'host' => env('PUSHER_HOST') ?: 'api-'.env('PUSHER_APP_CLUSTER', 'mt1').'.pusher.com',
                'port' => env('PUSHER_PORT', 443),
                'scheme' => env('PUSHER_SCHEME', 'https'),
                'encrypted' => true,
                'useTLS' => env('PUSHER_SCHEME', 'https') === 'https',
            ],
            'client_options' => [
                // Guzzle client options: https://docs.guzzlephp.org/en/stable/request-options.html
            ],
        ],

and in .ENV add pusher app key ,secret ,host , port , schema and cluster

PUSHER_APP_ID=local
PUSHER_APP_KEY=local
PUSHER_APP_SECRET=local
PUSHER_HOST=127.0.0.1
PUSHER_PORT=6001
PUSHER_SCHEME=http
PUSHER_APP_CLUSTER=mt1

now we can use WebSockets

php artisan websockets:serve

and in different terminal run laravel server and go
http://127.0.0.1:8000/laravel-websockets
to see dashboard

php artisan serve

Broadcasting Laravel Event on a public channel
To enable our server to send messages to the client in a public channel that doesn't require authentication, we'll begin by creating an event. This event will serve as a trigger for broadcasting messages.

php artisan make:event PublicMessageEvent

To broadcast our event using the ShouldBroadcast interface, we need to implement it in our event class (app\Events\PublicMessageEvent.php in your example). This interface provides the necessary methods to broadcast the event and specify the channel to broadcast on.

<?php

namespace App\Events;

use Illuminate\Broadcasting\Channel;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Broadcasting\PresenceChannel;
use Illuminate\Broadcasting\PrivateChannel;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;
use App\Http\Traits\WebSocketsTrait;


class PublicMessageEvent implements ShouldBroadcast
{
    use Dispatchable, InteractsWithSockets, SerializesModels,WebSocketsTrait;

    /**
     * Create a new event instance.
     */
    public $data;
    public function __construct()
    {
        //
    }



    /**
     * Get the channels the event should broadcast on.
     *
     * @return array<int, \Illuminate\Broadcasting\Channel>
     */
    public function broadcastOn()
    {
        $this->data = $this->status();

        return [
            new Channel('public'),
        ];
    }
}

By default, the event will be stored in a queue job but if you want to broadcast immediately use ShouldBroadcastNow interface.

and in web add that route

Route::get('/status', [\App\Http\Controllers\WebSocket::class, 'status']);

you can broadcast the event and create method in controller

<?php

namespace App\Http\Controllers;

use App\Events\PublicMessageEvent;
use Illuminate\Http\Request;

class WebSocket extends Controller
{
    public function status () {
         broadcast(new PublicMessageEvent());
    }
}

I utilize the WebSocketsTrait to broadcast messages, eliminating the need to navigate to a specific channel.

<?php

namespace App\Http\Traits;

use App\Models\User;

trait WebSocketsTrait
{
    public function status()
    {

        return User::all();
    }


}

Notice you don’t have to declare a public channel in routes\channels.php

now all things look fine

To begin, follow these steps to open the Laravel WebSockets dashboard and establish a connection:
1-open the Laravel websockets dashboard http://127.0.0.1:8000/laravel-websockets

2-click connect button and make sure you use the port 6001

then in another browser tab go to http://127.0.0.1:8000/status
you should see all Users .
you can see channel name and the event name as well in api-message in WebSockets dashboard.

To listen for the event broadcasted from the Laravel backend in frontend frameworks like Vue, React, or any other framework, you can utilize Laravel Echo. Laravel Echo is a JavaScript library that simplifies the process of subscribing to channels and listening for events.

CONCLUSION
In conclusion, by integrating Laravel WebSockets into your backend infrastructure, you can unlock the potential of real-time communication between the server and the client. Leveraging WebSockets allows you to establish persistent connections, enabling bidirectional data flow and facilitating the development of dynamic and interactive applications. By following the steps outlined in this tutorial, you'll have the foundation to implement Laravel WebSockets and leverage its power in your backend architecture. Happy coding!

Laravel Security

Hallo Rzgar — Fri, 17 Feb 2023 12:12:58 +0000

Laravel is one of the most popular PHP frameworks, known for its simplicity, elegance, and robustness. Laravel has been built with security in mind, and its framework includes many features that can help you deploy your application more securely. In this article, we will discuss some of the key security concerns when deploying Laravel applications, and we will provide code examples of how to mitigate them.

1. Deploying Securely

Deploying your Laravel application securely is critical. The first step is to ensure that your server is up-to-date with the latest security patches. Next, make sure that you have set up HTTPS properly. HTTPS is essential for securing data transmission between your application and your users. To set up HTTPS, you will need to obtain an SSL certificate and configure your web server to use it.

Another key aspect of deploying securely is to protect sensitive files and directories on your server. Laravel comes with a .htaccess file that can help you restrict access to certain directories. You should also set appropriate file permissions to ensure that only authorized users can access files.

2. Missing Authorization

One of the most common security vulnerabilities in web applications is missing authorization. Laravel provides built-in mechanisms for handling authentication and authorization, such as middleware and guards. Middleware can be used to restrict access to certain routes, while guards can be used to authenticate users based on different drivers, such as session or token-based authentication.

Here is an example of how to use middleware to protect a route:

Route::get('/dashboard', function () {
    // Only authenticated users can access this route
})->middleware('auth');

And here is an example of how to use a guard to authenticate a user based on a token:

if (Auth::guard('api')->check()) {
    // The user is authenticated via an API token
}

3. User Input

User input is a common source of security vulnerabilities, such as cross-site scripting (XSS) and SQL injection. To prevent XSS, Laravel provides a Blade template engine that automatically escapes user input. To prevent SQL injection, you should use parameterized queries when interacting with your database. Here is an example:

$users = DB::select('SELECT * FROM users WHERE id = ?', [$id]);

4. Markdown Security Concerns
Markdown is a popular syntax for writing formatted text, but it can also be a security concern. Markdown can include HTML, which can lead to XSS vulnerabilities. To mitigate this, Laravel provides a Markdown engine that can sanitize HTML input. Here is an example of how to use the Laravel Markdown engine:

{{ Illuminate\Mail\Markdown::parse($text) }}

5. Sensitive Attributes
Sensitive attributes, such as passwords, should be hashed before storing them in the database. Laravel provides a built-in hashing mechanism that can be used to hash passwords. Here is an example:

$hashedPassword = Hash::make($password);

Additionally, you should encrypt sensitive data using Laravel's encryption facilities. Here's an example of how to encrypt and decrypt data in Laravel:

$encryptedData = encrypt('sensitive data');
$decryptedData = decrypt($encryptedData);

6. Rate Limiting is a Must

Rate limiting is an essential feature for preventing brute force attacks and DoS attacks. Laravel provides a built-in rate limiting feature that can be used to limit the number of requests from a single IP address. Here is an example of how to use Laravel's rate limiting feature:

Route::middleware('throttle:60,1')->group(function () {
    // This route can be accessed 60 times per minute per IP address
});

In conclusion, Laravel is a secure and robust framework, but it still requires careful attention to security when deploying your application. By following best practices and using the built-in security features of Laravel, you can deploy a secure and reliable web application.

How to Optimizing Laravel Performance ?

Hallo Rzgar — Tue, 31 Jan 2023 09:29:25 +0000

What is Optimizing in Laravel ?

Refers to the process of making improvements to the speed, efficiency and scalability of a Laravel application. This can be achieved by reducing the amount of resources required by the application, minimizing the number of database queries, and using caching to store frequently used data. Other techniques for optimizing Laravel performance include using pagination, enabling gzip compression, using a content delivery network (CDN), and profiling the application to identify and resolve performance bottlenecks.

It's important to think about performance optimization. Here are Some tips and tricks to help you improve the performance of your Laravel application:

1- Caching: Laravel provides several caching mechanisms, including view caching, route caching, and model caching. By using these mechanisms, you can store the results of expensive database queries or calculations so that you don't have to perform them every time a user requests a page.

2- Optimizing database queries: Laravel's Eloquent ORM makes it easy to perform database queries, but it's important to make sure your queries are optimized. Consider using indexing to speed up your queries, and limit the number of records returned by a query to only what you need.

3- Minimizing the number of database connections: Laravel uses database connections to interact with your database, but having too many connections can slow down your application. You can minimize the number of connections by pooling them, or by using a connection manager like PDO.

4- Using pagination: Laravel provides built-in support for pagination, which allows you to split a large number of records into smaller, more manageable chunks. By using pagination, you can reduce the amount of data that needs to be transferred between the server and the client, which can help improve performance.

5- Optimizing images: Large images can slow down your application, so it's important to optimize them. Consider compressing your images, and using image optimization tools to reduce their file size.

6- Enabling gzip compression: Gzip compression compresses your HTML, CSS, and JavaScript files, which can help reduce the size of the data that needs to be transferred over the network. Laravel provides an easy way to enable gzip compression in your application, so consider doing this if your application is not already using it.

7- Profiling your application: Laravel provides a built-in profiler that you can use to identify performance bottlenecks in your application. The profiler provides information about database queries, memory usage, and other performance metrics, which can help you identify areas of your application that need optimization.

By following these tips and tricks, you can help improve the performance of your Laravel application, making it faster and more responsive for your users.

Sure, here are a few examples to illustrate each of the tips and tricks mentioned in the previous article:

1-Caching: In Laravel, you can cache the results of an expensive database query or calculation using the Cache facade. For example:

use Illuminate\Support\Facades\Cache;

$results = Cache::remember('key', $minutes, function () {
    return DB::table('table')->get();
});

2-Optimizing database queries: When using Eloquent, you can use eager loading to reduce the number of database queries. For example:

$users = User::with('posts')->get();

3-Minimizing the number of database connections: You can pool database connections in Laravel by using a connection manager like PDO. For example:

use Illuminate\Support\Facades\DB;

$pdo = DB::connection()->getPdo();

$statement = $pdo->prepare('SELECT * FROM users');

$statement->execute();

$results = $statement->fetchAll();

4- Using pagination: In Laravel, you can use the paginate method to easily paginate your database results. For example:

$users = User::paginate(10);

5- Optimizing images: In Laravel, you can use a package like Intervention Image to optimize your images. For example:

use Intervention\Image\Facades\Image;

$image = Image::make('public/image.jpg')->resize(320, 240)->save('public/image-optimized.jpg');

6- nabling gzip compression: In Laravel, you can enable gzip compression by adding the following to your .htaccess file

<IfModule mod_deflate.c>
  AddOutputFilterByType DEFLATE text/text text/html text/plain text/xml text/css application/javascript
  <IfModule mod_setenvif.c>
    BrowserMatch ^Mozilla/4 gzip-only-text/html
    BrowserMatch ^Mozilla/4\.0[678] no-gzip
    BrowserMatch \bMSIE !no-gzip !gzip-only-text/html
  </IfModule>
</IfModule>

7- Profiling your application: In Laravel, you can use the built-in profiler to profile your application. To do this, simply add the following to the end of your .env file:

APP_DEBUG=true

Conclusion
optimizing Laravel performance is an important task for ensuring a fast, efficient, and scalable Laravel application. The techniques for optimizing Laravel performance can vary depending on the specifics of the application, by implementing those techniques and continually monitoring the performance of the application, developers can ensure that Laravel applications perform optimally and provide a positive experience for users.

Why Laravel 🤔 ??

Hallo Rzgar — Mon, 16 Jan 2023 13:29:40 +0000

What is laravel ?
Laravel is a PHP based web-framework for building
high-end web applications using its significant and
graceful syntaxes. Laravel was developed by Taylor
Otwell in July 2011 and it was released more than five
years after the release of the Codeigniter. It comes with
a strong collection of tools and provides application
architecture.

How it work
Laravel use MVC
MVC is a short form for ‘Model
View Controller’. This illustrates the use of structure
developers when constructing applications. MVC basically is
a software which separates utility/domain/commercial
enterprise in terms of the interface of customers. This is done
by breaking MVC software into the further three parts: first
is the Model, second is the View, and the last one is the
Controller. The model handles basic machine behaviours and
information. It answers to instructions to change the status of
its documents and also to alert observers of periodic systems
when the facts change. This may be a database or a retrieval
device. So, in short, this is the record-management of the
programme or software. View correctly provides the
software's user interface feature and display information into
a form via a model which is sufficient for the interface of the
user. The controller gets the data request from the user and
passes it to the model objects and sees the execution of
appropriate actions.

8 Benefits of Laravel Framework

It's quick and simple.
Security is key.
Better website performance.
Great for Traffic-Handling.
Really Flexible.
Easy third-party integrations.
Simple Website Maintenance.
The cost of a Laravel Site.

Some Features of Laravel

Authentication.
Innovative Template Engine.
Effective ORM.
MVC Architecture Support.
Secure Migration System.
Unique Unit-testing.
Intact Security.
Libraries and Modular.

Laravel Packages Which You Can Use to Optimize App

Spatie.
Laravel Debugbar.
Laravel User Verification.
Socialite.
Migration Generator.