DEV Community: Hamid Haghdoost

PHP Attributes: Modern Metadata in Your Code

Hamid Haghdoost — Thu, 11 Sep 2025 13:56:52 +0000

Since PHP 8, we’ve had attributes — a modern way to add metadata directly to classes, methods, or properties. Think of them like annotations in Java or decorators in Python.

🔖 What are attributes?

Attributes let you “tag” parts of your code with extra information. Frameworks or libraries can then read these tags at runtime and act on them.

Example:

#[Route('/home', methods: ['GET'])]
class HomeController {
    // ...
}

Here, the Route attribute describes how this controller should be exposed.

⚙️ How do you define an attribute?

Attributes are just classes marked with #[Attribute].

use Attribute;

#[Attribute]
class Route {
    public function __construct(
        public string $path,
        public array $methods = ['GET']
    ) {}
}

🔍 How to read attributes with Reflection

You can fetch and use attributes at runtime via the Reflection API:

$reflection = new ReflectionClass(HomeController::class);

// Get all attributes on the class
foreach ($reflection->getAttributes(Route::class) as $attr) {
    // Turn attribute into a real object
    $route = $attr->newInstance();

    echo $route->path;     // "/home"
    echo implode(',', $route->methods); // "GET"
}

This is how frameworks like Symfony or Doctrine process metadata and apply logic automatically.

✅ Why use attributes?

Cleaner than PHPDoc comments
More flexible than marker interfaces
Supported natively by PHP, no hacks needed

🏛️ Where are they used?

Symfony → #[Route] for controllers
Doctrine ORM → #[Entity], #[Column] for database mapping
Custom apps → logging, caching, validation rules

🔑 In short: Attributes bring structured, modern metadata to PHP. They’re concise, powerful, and built right into the language — and with reflection, they let your code adapt based on annotations.

How I Freed Up Tons of Storage on My Mac

Hamid Haghdoost — Sun, 24 Aug 2025 10:25:26 +0000

My Mac was almost full. It said that “Documents” used 39 GB, but I didn’t know what was taking so much space. As a software developer, I have tools like npm, Docker, and Homebrew that keep files to work faster. These files can get very big. Here’s how I fixed it.

Step 1: Look at Documents

I checked my Documents folder in Finder, but the files there were much smaller than 39 GB. Then I used Terminal:

du -sh ~/Documents/* | sort -h

This shows the size of each file and folder. Most were small. So the big files were hidden in caches and tools.

Step 2: Clear developer tool caches

npm (Node.js)

du -sh ~/.npm
npm cache clean --force

This freed 3.5 GB.

Docker

docker system df
docker builder prune

My Docker cache alone was 19 GB!

Homebrew

du -sh ~/Library/Caches/Homebrew
brew cleanup

This cleared hundreds of MBs.

VSCode

rm -rf ~/Library/Application\ Support/Code/Cache/*
rm -rf ~/Library/Application\ Support/Code/CachedData/*
rm -rf ~/Library/Application\ Support/Code/User/workspaceStorage/*

This freed about 5 GB.

Step 3: Remove old tools you don’t use

I had old versions of PHP and some apps I didn’t use. I removed them:

brew uninstall php@7.1 php@7.4 php@8.0
brew uninstall --cask fig
brew uninstall nginx

Step 4: Check other caches

Other tools also store caches:

Python pip: ~/.cache/pip
Go modules: ~/go/pkg/mod/cache
iCloud: ~/Library/Mobile Documents

You can check their size with:

du -sh <folder>

Step 5: Keep it clean

I now run these commands every few weeks:

npm cache clean --force
docker builder prune
brew cleanup
rm -rf ~/Library/Caches/*

This keeps my Mac from filling up again.

Lessons learned

Most big storage is hidden in caches, not in Documents.
Tools like Docker, npm, Homebrew, and VSCode can use lots of GB.
Cleaning regularly can free 20–40 GB.
Terminal commands like du -sh and docker system df help find big files.

With these steps, my Mac now has plenty of space and runs better.

Kubernetes Service Account and RBAC Tutorial

Hamid Haghdoost — Thu, 16 Jan 2025 13:37:02 +0000

Kubernetes Service Account and RBAC Tutorial

Introduction

In this tutorial, we created a Service Account with a Role and RoleBinding for read-only access to Pods. You can find the source code in the GitHub repository.

What is a Service Account in Kubernetes?

A Service Account in Kubernetes is a special type of account that is used by processes or applications running inside Pods to authenticate and interact with the Kubernetes API. Unlike User Accounts, which are typically associated with human users, Service Accounts are designed for non-human access. They are used to grant specific permissions to applications, allowing them to interact with the Kubernetes cluster in a controlled and secure way.

How Does a Service Account Work?

Service accounts provide a mechanism for granting RBAC (Role-Based Access Control) permissions to Pods and workloads. Each service account has a set of credentials (a token) that is automatically generated by Kubernetes. This token is mounted into the container running inside a Pod, which allows the application to authenticate itself against the Kubernetes API.

Through the service account, Kubernetes manages the access control for specific resources (such as Pods, Services, ConfigMaps, etc.), based on the Role or ClusterRole associated with the account. These roles define what actions the service account can perform on different resources within the cluster.

In essence, a Service Account acts as an identity for the applications or workloads running inside your Kubernetes Pods. By linking it with roles and permissions, Kubernetes enables fine-grained access control, ensuring that each service only has access to the resources it needs.

Prerequisites

Before starting this tutorial, you should have:

A Kubernetes cluster (either local or on a cloud provider).
kubectl installed and configured to access the cluster.
Basic knowledge of Kubernetes Pods and RBAC.

Step 1: Create a Service Account

A Service Account is an identity for processes running inside Pods. It allows Pods to authenticate and interact with the Kubernetes API.

First, create a file named service-account.yaml to define the Service Account:

apiVersion: v1
kind: ServiceAccount
metadata: 
  name: print-read-service-account
  namespace: service-account-test

This file defines a service account named print-read-service-account in the service-account-test namespace.

To apply the Service Account to your Kubernetes cluster, run:

kubectl apply -f service-account.yaml

Step 2: Create a Role with Read Access to Pods

In Kubernetes, a Role defines what resources can be accessed within a specific namespace and what actions can be performed. Here, we'll create a Role that grants read-only access to pods.

Create a file named role.yaml with the following content:

apiVersion: rbac.authorization.k8s.io/v1
kind: Role 
metadata:
  name: read-role
  namespace: service-account-test
rules: 
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "list"]

This Role grants permission to get and list pods in the service-account-test namespace.

To apply the Role, run:

kubectl apply -f role.yaml

Step 3: Create a RoleBinding to Bind the Role to the Service Account

A RoleBinding is used to bind a Role to a specific Service Account. This allows the service account to use the permissions defined in the Role.

Create a file named role-binding.yaml:

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-role-binding
  namespace: service-account-test
subjects:
- kind: ServiceAccount
  name: print-read-service-account
  namespace: service-account-test
roleRef:
  kind: Role
  name: read-role
  apiGroup: rbac.authorization.k8s.io

This RoleBinding binds the read-role to the print-read-service-account service account.

To apply the RoleBinding, run:

kubectl apply -f role-binding.yaml

Step 4: Create a Pod that Uses the Service Account

Now, create a Pod that uses the print-read-service-account service account to access Kubernetes resources. This Pod will use the kubectl command to list pods and services in the cluster.

Create a file named pod-with-service-account.yaml:

apiVersion: v1
kind: Pod
metadata:
  name: pod-with-service-account
  namespace: service-account-test
spec:
  serviceAccountName: print-read-service-account
  containers:
  - name: print-reader-container
    image: bitnami/kubectl:latest
    command: ['sh', '-c', 'kubectl get pods && kubectl get services']

This Pod runs a container with the kubectl image. The container executes the command kubectl get pods && kubectl get services, which will attempt to retrieve both Pods and Services in the cluster.

To apply the Pod, run:

kubectl apply -f pod-with-service-account.yaml

Step 5: Verify the Pod Logs

Once the Pod is created, you can check the logs of the Pod to verify that it can read pods and services.

Run the following command:

kubectl logs pod-with-service-account -n service-account-test

Example Output:

NAME                       READY   STATUS    RESTARTS        AGE
pod-with-service-account   1/1     Running   6 (2m48s ago)   5m47s
Error from server (Forbidden): services is forbidden: User "system:serviceaccount:service-account-test:print-read-service-account" cannot list resource "services" in API group "" in the namespace "service-account-test"

Explanation:

In the log above, the kubectl command successfully lists the pods, but it encounters an error when trying to list the services. The error message indicates that the service account print-read-service-account does not have permission to access the services resource. This is because the Role only grants access to pods and not services.

To fix this, you need to update the Role to grant read access to both pods and services.

Step 6: Update the Role to Access Services

Edit the role.yaml file to include access to services:

apiVersion: rbac.authorization.k8s.io/v1
kind: Role 
metadata:
  name: read-role
  namespace: service-account-test
rules: 
- apiGroups: [""]
  resources: ["pods", "services"]
  verbs: ["get", "list"]

Reapply the updated Role:

kubectl apply -f role.yaml

Now, when you check the Pod logs again, you should see both pods and services listed.

By default, a Kubernetes Service Account has access only to resources within the namespace it is created in. This means that the print-read-service-account in our example can only interact with resources like Pods and Services within the service-account-test namespace. If you want the service account to have access to resources in other namespaces, you need to use a ClusterRole and ClusterRoleBinding instead of a Role and RoleBinding. A ClusterRole grants access to resources across the entire cluster, and a ClusterRoleBinding allows you to bind the ClusterRole to a service account across multiple namespaces or cluster-wide.

Conclusion

In this tutorial, you learned how to:

Create a Service Account for use by a Kubernetes Pod.
Create a Role that grants read-only access to Pods.
Bind the Role to the Service Account using a RoleBinding.
Deploy a Pod that uses the Service Account to interact with Kubernetes resources.

By following these steps, you can control access to Kubernetes resources securely using RBAC and Service Accounts, ensuring that applications only have access to the resources they need.

Hashicorp Vault Agent Tutorial: Generating .env from Vault Secrets

Hamid Haghdoost — Thu, 02 Jan 2025 14:35:16 +0000

In this tutorial, we will set up Vault Agent to generate a .env file with secrets from HashiCorp Vault. We’ll use the AppRole authentication method to securely authenticate and retrieve secrets, then write them to an environment file for use in your application.

You can find the complete configuration files and setup used in this tutorial in the GitHub repository.

⚠️ Important Note: This tutorial uses Vault in development mode (-dev) for simplicity. Development mode is not secure and should only be used for testing and learning purposes. In a production environment:

Use a properly initialized and unsealed Vault server.
Secure the Vault server with TLS certificates and access control.

Prerequisites

Vault server running (in development mode for testing)
Vault Agent installed and configured
Basic knowledge of Vault and its authentication methods

Step 1: Start Vault Server in Development Mode

We’ll start Vault in development mode for testing purposes. This will make Vault accessible via 127.0.0.1:8200 with a root token.

Run the following command:

vault server -dev -dev-root-token-id=root -dev-tls

Then export VAULT_ADDR and VAULT_CACERT from the output of previous command to give the ability to cli to have access to Vault server:

export VAULT_ADDR='https://127.0.0.1:8200'
export VAULT_CACERT='/tmp/vault-tls900287623/vault-ca.pem'

And create two dummy secrets as username and password of a database that later we want to write them in a env variable:

vault kv put secret/dbinfo user=root pass=test123

Access Vault’s UI by navigating to https://127.0.0.1:8200 and logging in with the root token.

Step 2: Set Up the AppRole Authentication Method

We will use AppRole for authentication. First, enable the AppRole authentication method:

vault auth enable approle

Next, create a new AppRole and attach a policy that allows reading from the secret/data/dbinfo path:

Create the Vault policy (agent-policy.hcl):

path "secret/data/dbinfo" {
  capabilities = ["read"]
}

Write the policy:

vault policy write agent-policy agent-policy.hcl

Create the AppRole and attach the policy:

vault write auth/approle/role/vault-agent-role policies="agent-policy"

Generate the role_id and secret_id:

vault read auth/approle/role/vault-agent-role/role-id
vault write -f auth/approle/role/vault-agent-role/secret-id

The role_id and secret_id are required to authenticate via AppRole. Save these values to the files role_id and secret_id.

Step 3: Configure Vault Agent

The Vault Agent configuration file (vault-agent.hcl) will authenticate with Vault using the AppRole and generate a .env file with the secret values. Here’s an example configuration:

# Vault Agent configuration
vault {
  address = "https://127.0.0.1:8200"
  token = "<client_token>"
}

auto_auth {
  method "approle" {
    mount_path = "auth/approle"
    config = {
      role_id_file_path = "./role_id"
      secret_id_file_path = "./secret_id"
    }
  }

  sink "file" {
    path = "./vault-agent-token"
  }
}

template {
  source      = "./env-template.tmpl"
  destination = "./.env"
}

Explanation:

The role_id_file_path and secret_id_file_path point to the files containing the AppRole credentials.
The template block specifies the path to the env-template.tmpl file and the destination for the generated .env file.

Step 4: Create the Template File (`env-template.tmpl`)

Create a template file (env-template.tmpl) that Vault Agent will use to generate the .env file. Here’s an example template:

DB_USER={{ with secret "secret/data/dbinfo" }}{{ .Data.data.user }}{{ end }}
DB_PASS={{ with secret "secret/data/dbinfo" }}{{ .Data.data.pass }}{{ end }}

This template will insert the user and pass from the Vault secrets into the .env file.

Step 5: Start Vault Agent

Now, we will start the Vault Agent to authenticate and generate the .env file:

vault agent -config=./vault-agent.hcl

Vault Agent will authenticate using AppRole, retrieve the secret from secret/data/dbinfo, and generate the .env file at the specified location.

Step 6: Check the Generated `.env` File

After Vault Agent runs, the .env file will be populated with the secrets from Vault:

DB_USER=root
DB_PASS=test123

This file can now be used to set environment variables for your application.

Your final files should be like this:

agent-policy.hcl
env-template.tmpl
role_id
secret_id
vault-agent.hcl
vault-agent.pid
vault-agent-token

Conclusion

In this tutorial, we’ve configured Vault Agent to authenticate with Vault using AppRole, retrieve secrets, and generate a .env file. This is a simple and secure way to manage sensitive configuration data in your application.

I hope this tutorial helps you get Vault Agent running smoothly. Happy coding! 🚀

A Simple Guide to Choosing Licenses for Your Projects

Hamid Haghdoost — Fri, 13 Dec 2024 08:41:14 +0000

If you are confused about licenses like me, this guide helps you decide on licenses for software, documentation, and other practical works. Here, I’ll provide a simplified (but probably not entirely accurate) version of it.

General Rule of Thumb:
- If you’re modifying an existing project, stick with its original license unless you have a really good reason to change it.
- If you do switch licenses, make sure it’s allowed and make it clear which parts use which license.
For Software:
- Use GNU GPL (General Public License) for most projects to make sure users have the freedom to use, share, and modify your work.
- For small programs (under 300 lines), use Apache License 2.0—it's simpler and less restrictive.
- For server software, pick GNU AGPL (Affero GPL) to ensure users can access the source code even when running online.
For Libraries:
- Use LGPL (Lesser GPL) if you expect proprietary software to use your library.
- Use GPL for libraries with specialized or unique use cases.
For Documentation:
- Use GNU Free Documentation License (GFDL) for big works like manuals.
- For smaller docs, use a simpler license like GNU all-permissive license.
For Icons, Fonts, and Other Works:
- If these are part of a software project, use the same license as the software.
- If they’re standalone, go for a Creative Commons Attribution-ShareAlike (CC BY-SA) license to keep them free and shareable.

What is Copyleft?

Copyleft is a way to make sure that software (or other creative works) remains free for everyone to use, share, and modify. It works by allowing anyone to use your work, but with the condition that if they make changes and share it, they must also make those changes available under the same free terms.

In simpler terms: it’s like sharing your recipe with friends, but telling them that if they make changes to it, they also have to share the updated recipe in the same way. This ensures that the work stays open and free for everyone.

And that’s pretty much it! The GNU Project recommends these licenses to keep your work free and accessible. If you’re still unsure, you can always contact their licensing team. 😊

Run Gitlab CI jobs on a specific runner

Hamid Haghdoost — Thu, 31 Oct 2024 09:18:07 +0000

I have two runners in my project. One is on Microsoft Azure for Azure deployments, and the other is on DigitalOcean for its deployments. Today, I realized that all of my jobs are being handled by the Azure runner, causing our tests to take too much time due to significant network delay when connecting to the database across data centers.

Therefore, I needed to configure specific jobs to run on designated runners. Here, I’ll explain how to do that.

To assign a specific GitLab Runner to a job in your GitLab CI/CD pipeline, use the tags keyword in the job definition in your .gitlab-ci.yml file. You’ll need to add a unique tag to the runner configuration in GitLab and then reference that tag in the job configuration. Here’s how:

Step 1: Add a Tag to the Runner

Go to your project’s Settings > CI / CD.
Under Runners, locate the runner you want to assign to your job.
Click on Edit (pencil icon) next to the runner and add a unique tag (for example, azure-runner).

Step 2: Use the Tag in Your `.gitlab-ci.yml`

Add the same tag to your job definition in the .gitlab-ci.yml file:

job_name:
  stage: build
  script:
    - echo "Running job on an Azure runner"
  tags:
    - azure-runner

Explanation

tags: By specifying the azure-runner tag, GitLab ensures this job will only be picked up by runners that have this tag.

Now, if you take a look at your job on GitLab, you will see that it is assigned to the specific runner you specified.

Install Docker and Docker Compose by single command and use it without sudo :)

Hamid Haghdoost — Fri, 08 Sep 2023 16:09:05 +0000

I know it looks crazy but to be honest I am frustrated of searching "install docker ubuntu" and copy paste lots of commands every time. If it happens for you a lot, you can bookmark this gist and just copy and paste it to install docker, compose and post installation commands.

for pkg in docker.io docker-doc docker-compose podman-docker containerd runc; do sudo apt-get remove $pkg; done  &&
sudo apt-get update &&
sudo apt-get install ca-certificates curl gnupg &&
sudo install -m 0755 -d /etc/apt/keyrings &&
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg &&
sudo chmod a+r /etc/apt/keyrings/docker.gpg &&
echo \
  "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update &&
sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin &&
sudo groupadd docker && 
sudo usermod -aG docker $USER && 
newgrp docker && 
sudo docker run hello-world

A shorter way

If you don't want to copy such a long command you can easily run this one:

 /bin/bash -c "$(curl -s https://gist.githubusercontent.com/tuytoosh/b700f17f3ee3ad7f20d533e61de31c56/raw)"

It downloads the gist and runs the commands after getting root password.
You can write an Ansible playbook as well to do the same:

- name: Install Docker on Debian
  hosts: all
  become: true
  tasks:
    - name: Remove conflicting Docker packages
      apt:
        name: "{{ item }}"
        state: absent
        purge: true
      loop:
        - docker.io
        - docker-doc
        - docker-compose
        - podman-docker
        - containerd
        - runc
      ignore_errors: true

    - name: Update apt repository cache
      apt:
        update_cache: yes

    - name: Install prerequisite packages
      apt:
        name:
          - ca-certificates
          - curl
          - gnupg
        state: present

    - name: Create keyrings directory for Docker
      file:
        path: /etc/apt/keyrings
        state: directory
        mode: '0755'

    - name: Add Docker's official GPG key
      ansible.builtin.command:
        cmd: curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
      args:
        creates: /etc/apt/keyrings/docker.gpg

    - name: Set permissions for Docker GPG key
      file:
        path: /etc/apt/keyrings/docker.gpg
        mode: '0644'

    - name: Add Docker repository
      ansible.builtin.apt_repository:
        repo: "deb [arch={{ ansible_architecture }} signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian {{ ansible_lsb.codename }} stable"
        filename: docker

    - name: Update apt cache after adding Docker repo
      apt:
        update_cache: yes

    - name: Install Docker packages
      apt:
        name:
          - docker-ce
          - docker-ce-cli
          - containerd.io
          - docker-buildx-plugin
          - docker-compose-plugin
        state: present

    - name: Create Docker group if it does not exist
      group:
        name: docker
        state: present

    - name: Add user to Docker group
      user:
        name: "{{ ansible_user }}"
        groups: docker
        append: yes

    - name: Run Docker hello-world to verify installation
      command: docker run hello-world
      register: docker_test_result
      failed_when: docker_test_result.rc != 0

Ciao e buon week-end :)

Hello world Kubernetes with Nginx on Minikube

Hamid Haghdoost — Fri, 18 Aug 2023 15:17:13 +0000

Kubernetes gives you the ability to deploy your app in a highly available way, and it has provisioning features that you can use to avoid manual tasks.
There are tons of tutorials about Kubernetes out there, but in this simple post, I just want to give you the simplest deployment ever in Kubernetes. You will see how to deploy nginx with Kubernetes and access it easily.
Before deployment, make sure you have properly installed kubectl and minikube, and remove any old stuff from minikube using the delete and start commands.

minikube delete
minikube start

If it works, so everything is fine. lets go ahead. The main part is the deployment.yaml file. write it in a file and apply it.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  selector:
    matchLabels:
      app: nginx
  replicas: 2
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80

and then apply it with:

kubectl apply -f deployment.yaml

Now if you check the deployments:

kubectl get deployments

You should see sth like this:

NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   2/2     2            2           29s

As you can see, there is an Nginx deployment with 2 replicas. In order to verify if it is actually working, we should check port 80 of the pods. Therefore, we need to find the IP of each pod by simply using this command:

kubectl get pods -o wide

And it should give you sth similar to this:

NAME                                READY   STATUS     RESTARTS   AGE     IP            NODE       NOMINATED NODE   READINESS GATES
nginx-deployment-57d84f57dc-6wk4h   1/1     Running    0          3m22s   10.244.0.10   minikube   <none>           <none>
...

In my case the IP of Pod is 10.244.0.10 which I should connect to the cluster and check port 80 of that. In Minikube we can SSH to the cluster simply with:

minikube ssh

Now check the <IP>:<PORT> with this command:

curl 10.244.0.10

If you get an output like this:

<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

It means your Nginx is working properly on the specified port. So you have a cluster with two Pods, each running an Nginx service.

Expose Nginx to the world

If you want to expose your service to outside to see in the browser you can use a LoadBalancer service like this:

apiVersion: v1
kind: Service
metadata:
  name: nginx-load-balancer
spec:
  selector:
    app: nginx
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: LoadBalancer

Apply it with:

kubectl apply -f load-balancer.yaml

And you should see an Nginx default page in your IP address.

This was the most basic deployment on Kubernetes, but every big thing is made up of small pieces. In the next posts, I will try to delve deeper into Kubernetes. Have a good time! :)

Laravel 10 new features

Hamid Haghdoost — Wed, 15 Feb 2023 17:00:17 +0000

Finally Laravel 10 is released. It requires PHP >= 8.1. Most of the features are added by the core Laravel team and not the other contributors and it seems that there is not a big changes compared previous version releases. Lets have a glance.

New Type Hinting Model

Nuno Maduro, creator of Pest has added new PHP style of type hinting and removed old way of dock-block in all stubs and maybe codebase. It seems that the change has not a sensible different for end-users :)

/**
* Display a listing of the resource.
*/
public function index(): Response
{
    // ...
}

Features with Pennant

Another core member of Laravel, named Tim MacDonald has developed a new package named Pennant that makes it easy to publish specific features for specific users. consider a situation that you have added a new feature and you want to test it on a small chunk of users. the package has introduced a convenient way for that.

use Laravel\Pennant\Feature;
use Illuminate\Support\Lottery;

Feature::define('new-onboarding-flow', function () {
    return Lottery::odds(1, 10);
});

Process Interaction in a simple way

This feature is a little bit funny. I have experience working with the commands line exec which we can run a program in OS's shell with PHP like ls -a. With this new feature, you can run this kind of command with a better coding interface:

use Illuminate\Support\Facades\Process;

$result = Process::run('ls -la');

return $result->output();

Profile tests

If your tests take too much to be ended (like me:)) try this feature. It profiles your tests and reports the execution time which makes it easy to find slow tests.

php artisan test --profile

Use Pest for testing

If you prefer the Pest PHP testing format for writing your tests, Now it is built in on Laravel and you can use it easily.

Command CLI prompts

This feature prompts the user to complete the command if it was not complete. For example, if you run a command like this:

php artisan make:controller

It asks you the name of controller. We can accept it from Jess :)

Better Horizon and Telescope

Finally if you are a fan of one of the above tools, there is a little bit face lift on them.

Overall, I think the changes were not big but that is the open-source world and we have to thank the contributors for their efforts. If you want a new thing, go and write it :) Have a good time.

Error types and error reporting in PHP

Hamid Haghdoost — Sun, 04 Dec 2022 19:41:36 +0000

It is important to know about error types in PHP. By this knowledge it would be easier to find and solve errors. Basically we have 4 types of error in PHP and I will show you them with an example.

1. Notice

PHP is not sure about whether is it an error or not!

2. Warning

An error that is important and should be fixed but does not stop code execution.

include("external_file.php");

Warning: include(external_file.php): Failed to open stream: No such file or directory in /Users/hamid/Codes/error.php on line 4

3. Parse error

When the compiler is unable to parse your code correctly. For example when a ; is missing.

if ($a == 1) {
    echo "something!"
}

Parse error: syntax error, unexpected token "}", expecting "," or ";" in /Users/hamid/Codes/error.php on line 12

4. Fatal error

When you have a critical error. Your code execution will be halted.

$c = 1 / 0;

Fatal error: Uncaught DivisionByZeroError: Division by zero in /Users/hamid/Codes/error.php:7
Stack trace:
#0 {main}
  thrown in /Users/hamid/Codes/error.php on line 7

Error reporting in PHP

You can ask PHP to show specific types of errors like these:

// Turn off all error reporting
error_reporting(0);

// Report simple running errors
error_reporting(E_ERROR | E_WARNING | E_PARSE);

// Reporting E_NOTICE can be good too (to report uninitialized
// variables or catch variable name misspellings ...)
error_reporting(E_ERROR | E_WARNING | E_PARSE | E_NOTICE);

// Report all errors except E_NOTICE
// This is the default value set in php.ini
error_reporting(E_ALL ^ E_NOTICE);

// Report all PHP errors (see changelog)
error_reporting(E_ALL);

// Report all PHP errors
error_reporting(-1);

// Same as error_reporting(E_ALL);
ini_set('error_reporting', E_ALL);

Thank you for reading...

Mock Config in Laravel

Hamid Haghdoost — Sat, 03 Sep 2022 19:45:19 +0000

Hi all. If you are testing your application and you need to make your config constant or change it to a specific value for testing you can mock it simply!
Config facade of Laravel has a method named set() which overwrites the default value of configs like this:

Config::set('name', 'Laravel');

So in testing env you can do something like this:

public function test_that_home_page_is_working()
{
    Config::set('name', 'Laravel');
    $this->get('/')->assertSee("Laravel");
}

Generally Laravel facades have several benefits because of their testability. You can Mock all facades of Laravel easily. Also if you want to have deeper knowledge about testing tools you can take a look at PHP Mockery.

Bootstrap open Accordion after Ajax loaded

Hamid Haghdoost — Sat, 04 Jun 2022 13:27:01 +0000

Accordion is a nice component of Bootstrap. It uses Collapse feature of Bootstrap. It works properly under the hood but sometimes you need to do something different. In my case I needed to click on accordion header, then send an Ajax request and get the content of accordion and then open it. There was not a straigh-forward API or document for that and finally I find it.

<script>
    let prevent = true;

    $("#collapseThree").on("show.bs.collapse", function (e) {
        if (prevent) {
            e.preventDefault();
        }
        setTimeout(function () {
            prevent = false;
            $("#collapseThree").collapse("show");
            prevent = true;
        }, 1000);
    });
</script>

In this example, I've added an event on the open state of collapse and I've used a setTimeout function for simulate Ajax request.

DEV Community: Hamid Haghdoost

PHP Attributes: Modern Metadata in Your Code

🔖 What are attributes?

⚙️ How do you define an attribute?

🔍 How to read attributes with Reflection

✅ Why use attributes?

🏛️ Where are they used?

How I Freed Up Tons of Storage on My Mac

Step 1: Look at Documents

Step 2: Clear developer tool caches

Step 3: Remove old tools you don’t use

Step 4: Check other caches

Step 5: Keep it clean

Lessons learned

Kubernetes Service Account and RBAC Tutorial

Kubernetes Service Account and RBAC Tutorial

Introduction

What is a Service Account in Kubernetes?

How Does a Service Account Work?

Prerequisites

Step 1: Create a Service Account

Step 2: Create a Role with Read Access to Pods

Step 3: Create a RoleBinding to Bind the Role to the Service Account

Step 4: Create a Pod that Uses the Service Account

Step 5: Verify the Pod Logs

Example Output:

Explanation:

Step 6: Update the Role to Access Services

Conclusion

Further Reading

Hashicorp Vault Agent Tutorial: Generating .env from Vault Secrets

Prerequisites

Step 1: Start Vault Server in Development Mode

Step 2: Set Up the AppRole Authentication Method

Step 3: Configure Vault Agent

Step 4: Create the Template File (env-template.tmpl)

Step 5: Start Vault Agent

Step 6: Check the Generated .env File

Conclusion

A Simple Guide to Choosing Licenses for Your Projects

What is Copyleft?

Run Gitlab CI jobs on a specific runner

Step 1: Add a Tag to the Runner

Step 2: Use the Tag in Your .gitlab-ci.yml

Explanation

Install Docker and Docker Compose by single command and use it without sudo :)

A shorter way

Hello world Kubernetes with Nginx on Minikube

Expose Nginx to the world

Laravel 10 new features

New Type Hinting Model

Features with Pennant

Process Interaction in a simple way

Profile tests

Use Pest for testing

Command CLI prompts

Better Horizon and Telescope

Error types and error reporting in PHP

1. Notice

2. Warning

3. Parse error

4. Fatal error

Error reporting in PHP

Mock Config in Laravel

Bootstrap open Accordion after Ajax loaded

Step 4: Create the Template File (`env-template.tmpl`)

Step 6: Check the Generated `.env` File

Step 2: Use the Tag in Your `.gitlab-ci.yml`