Blog

Details
Category: Symfony Framework

The best way to implement a SOAP client is using Symfony Framework. You can follow these easy steps:

 

Step 1: Install the required dependencies

Make sure you have the required dependencies installed in your Symfony project. You'll need the symfony/http-client and symfony/serializer components. If you don't have them installed, you can use Composer to install them:

$ composer require symfony/http-client symfony/serializer

 

Step 2: Create a SOAP service class
Create a new class that will act as your SOAP service client. This class will handle the communication with the SOAP server. Here's an example:

namespace App\Service;

use Symfony\Contracts\HttpClient\HttpClientInterface;
use Symfony\Component\Serializer\SerializerInterface;

class SoapService
{
    private $httpClient;
    private $serializer;
    private $soapEndpoint;

    public function __construct(HttpClientInterface $httpClient, SerializerInterface $serializer)
    {
        $this->httpClient = $httpClient;
        $this->serializer = $serializer;
        $this->soapEndpoint = 'http://example.com/soap-endpoint';
    }

    public function callSoapOperation($param1, $param2)
    {
        $soapRequest = $this->serializer->serialize(['param1' => $param1, 'param2' => $param2], 'xml');

        $response = $this->httpClient->request('POST', $this->soapEndpoint, [
            'headers' => ['Content-Type' => 'text/xml'],
            'body' => $soapRequest
        ]);

        if ($response->getStatusCode() === 200) {
            $soapResponse = $response->getContent();
            // Process the SOAP response
            // ...
            return $soapResponse;
        } else {
            throw new \Exception('SOAP request failed');
        }
    }
}

In this example, the SoapService class uses the Symfony HTTP Client and Serializer components. The constructor injects the HttpClientInterface and SerializerInterface to handle the HTTP communication and serialization of the SOAP requests. The callSoapOperation method sends the SOAP request to the server and handles the response.

Details
Category: Symfony Framework

You can deserialize complex nested Xml files into DTO Classes in Symfony in very simple steps using the JMS Serializer Bundle. Just follow these steps:

 

Step 1: Install Required Packages
Make sure you have the JMS Serializer Bundle installed. You can install it using Composer:

composer require jms/serializer-bundle

 

Step 2: Configure JMS Serializer Bundle
Configure the JMS Serializer Bundle in your Symfony application. Open your config/packages/jms_serializer.yaml file and add the following configuration:

jms_serializer:
    metadata:
        auto_detection: true

This configuration enables the JMS Serializer Bundle to automatically detect and use your DTO classes. For more configuration settings refer to the JMS Serializer Config page.

Details
Category: Symfony Framework

Symfony cache is a very powerful tool for caching resource-intensive time-consuming operations, like a report or anything that makes sense to have it cached. In my case, I use to cache in advance results I know in advance the users will be asking for, using a cron job that updates the cached data every hour, comparing the new version of the data with the cached version and deciding if refreshing the cache.

This way, the users will always have fresh updated data loaded very fast. Some of these reports take more than 15 min in getting processed. I also use to have a replica dedicated only to run these cron jobs so to not impact workload on the servers used by the clients.

For most use cases, the standard file system cache is good enough to provide fast page loads (take a look at my article How to implement caching in Symfony 5+), however, sometimes is much better to have this cache handled by a redis pool. To implement Symfony cache using Redis, just follow these simple steps:

 

Install the Redis extension for PHP

pecl install redis

 

Install the Redis adapter for Symfony

composer require symfony/cache
composer require symfony/cache-adapter
composer require symfony/cache-adapter-redis

 

Configure Redis in your Symfony application
Open the config/packages/framework.yaml file and add the following configuration:

# config/packages/cache.yaml
when@dev:
    framework:
        cache:
            pools:
                client_portal_pool_dev:
                    default_lifetime: 3600 #10 min in Dev 
                    adapter: cache.adapter.redis
                    provider: 'redis://redisKey@ip:6380'

when@prod:
    framework:
        cache:
            pools:
                client_portal_pool_prod:
                    default_lifetime: 10800 #3 Hr in Prod
                    adapter: cache.adapter.redis
                    provider: 'redis://redisKey@ip:6380'

 Also, notice how I'm using 2 different Redis pools for each environment. This is very important to keep in mind if you are using a cache provider like Redis, where you need to keep a clear separation of caching pools and not mess with production data.

Details
Category: Cloud Virtualization

CentOS (Community Enterprise Operating System) is a Linux distribution based on the freely available source code of Red Hat Enterprise Linux (RHEL). It aims to provide a free, open-source, and community-driven alternative to the commercially supported RHEL distribution.It become the defacto operating system for most servers hosting a big portion of all web sites available today, However, upcoming CentOS 9 is going to be available only as CentOS Stream, which for many developers it might not be the right solution. You may want to take a look at my article Key differences between CentOS and CentOS Stream

CentOS has been widely adopted in many organizations, especially those that require a stable and reliable Linux distribution without the need for commercial support. However, it's worth noting that CentOS has undergone some changes in recent years, with CentOS Stream being introduced as a rolling-release distribution closely tied to the development of RHEL.

 

There are several alternative operating systems to CentOS that you can consider. Here are some popular options:

 

AlmaLinux

AlmaLinux is a community-driven, open-source Linux distribution that serves as a drop-in replacement for CentOS. It is designed to be binary-compatible with Red Hat Enterprise Linux (RHEL) and provides long-term support.

Key features:

-Binary Compatibility: AlmaLinux is binary-compatible with Red Hat Enterprise Linux (RHEL). This means that applications and software packages built for RHEL can run on AlmaLinux without requiring any modifications, making it a seamless replacement for CentOS.

- Long-Term Support (LTS): AlmaLinux offers long-term support similar to CentOS. It provides regular security updates, bug fixes, and maintenance updates, ensuring stability and reliability for enterprise users.

- Community-Driven: AlmaLinux is a community-driven project that encourages community involvement and contributions. It is backed by the AlmaLinux OS Foundation, which aims to provide a sustainable and collaborative environment for the development and maintenance of the distribution.

- Predictable Release Cycle: AlmaLinux follows a predictable release cycle, ensuring that users can plan their updates and deployments accordingly. This helps organizations maintain stability and minimize disruptions.

- Familiar User Experience: AlmaLinux provides a user experience similar to CentOS, making it familiar to CentOS users. It uses the same package management system (RPM) and includes common tools and utilities found in CentOS/RHEL distributions.

- Security and Stability: AlmaLinux prioritizes security and stability, providing a reliable platform for critical applications and services. It undergoes rigorous testing and includes features such as SELinux (Security-Enhanced Linux) for enhanced system security.

- Backed by AlmaLinux OS Foundation: AlmaLinux is backed by the AlmaLinux OS Foundation, which ensures the long-term development, maintenance, and support of the distribution. The foundation works closely with the community and stakeholders to provide a sustainable and independent alternative to CentOS.

These key features make AlmaLinux a compelling choice for those seeking a stable, community-driven, and compatible alternative to CentOS.

Some sample commands that you can use with AlmaLinux:

Update the System

sudo yum update

This command updates the packages installed on your AlmaLinux system to the latest available versions.