DEV Community: Hamed0406

🚀 Introducing gofind – a blazing fast file finder in Go

Hamed0406 — Tue, 02 Sep 2025 09:23:52 +0000

Hi everyone! 👋

I’ve been working on a side project called gofind
, and I’m happy to finally share it with you. 🎉

🔍 Why I built gofind

We all know the classic find command – it’s powerful but sometimes:

It feels slow on large directories.

It has a complicated syntax that’s hard to remember.

It doesn’t always give you exactly the filtering you want without chaining extra tools.

That’s where gofind comes in.
It’s designed to make searching files simpler, faster, and more intuitive without sacrificing flexibility.

✨ Features

⚡ Fast and efficient – powered by Go’s concurrency

📝 Flexible filters – search by name, size, or modification time

📦 Cross-platform – works on Linux, macOS, and Windows

🛠️ Simple CLI – easy-to-remember flags

✅ CI/CD ready – integrated with GitHub Actions + GoReleaser

🛠️ What problems does it solve?

Developers who need to quickly find source files while working in large repos.

Sysadmins who want to locate big files that eat up disk space.

Security engineers who need to scan for recently modified files after an incident.

Anyone who wants a cleaner and faster alternative to the traditional find command.

📥 Installation

If you have Go installed:

go install github.com/Hamed0406/gofind@latest

Or grab the latest binary from the Releases
page.

🖥️ Example usage
Find all .go files modified in the last 24 hours

gofind -name "*.go" -mtime -1
Find files larger than 50MB

gofind -size +50M
🔧 Roadmap

JSON output for easy scripting

Even faster parallel searching

Integration with system indexing APIs

🙌 Contributions

I’d love feedback, feature requests, or bug reports.
Feel free to open an issue
or send a PR if you’d like to contribute!

🔗 Links

GitHub repo: github.com/Hamed0406/gofind

Releases: Download binaries

Red Hat Unwrapped: A Beginner's Journey into Enterprise Linux #2

Hamed0406 — Fri, 16 May 2025 14:23:54 +0000

In our earlier chapter, we covered some Linux basics, and the other half was about RHEL in the enterprise world. Let's turn to the other side-nearly practical: putting RHEL in your Windows environment using Windows Subsystem for Linux 2 (WSL 2).

🚀 Why Use RHEL on WSL 2?

✅ Integration! Run RHEL side by side with the Windows application without altering hard disk partitions, dual-boots, or separately maintained virtual machines.
⚡Development Efficiency: Developers can build Linux applications on Windows for a more efficient workflow since they are accustomed to working between both environments.
📦 Access RHEL Tools: One can take advantage of RHEL's powerful package management system and enterprise-grade tools on the Windows system.

📌 Installing RHEL on WSL 2
1️⃣ Enable WSL and Set Version to 2:
Open PowerShell as Administrator and execute:

wsl --install
wsl --set-default-version 2

2️⃣ Download the RHEL WSL Image:
View the Red Hat Customer Portal, navigate to the Downloads section, and pick up the RHEL WSL image (usually a .tar file).
You can sig up for Red Hat account if you don't have it already , it is free for developer . RHEL Account

3️⃣Import the RHEL Image into WSL:
Run in PowerShell:

wsl --import RHEL C:\WSL\RHEL C:\Path\To\Downloaded\RedHat.tar --version 2

4️⃣ Start RHEL:
Launch your instance of RHEL with:

wsl -d RHEL

5️⃣ Register and Update RHEL:
After entering the RHEL environment:

sudo subscription-manager register --username <your-username> --password <your-password>
sudo subscription-manager attach --auto
sudo dnf update -y

🎯Benefits of This Setup
🌐 Unified Environment: Develop, test, and deploy Linux applications without leaving your Windows workspace.

🚀Resource-efficient: WSL 2, as a lightweight virtualization solution, consumes considerably fewer resources than a traditional virtual machine.

⚡Productivity boost: Quickly switch back and forth between Windows and Linux tools for better productivity in all development and administrative needs.
linux-os.net

By deploying RHEL to Windows via WSL 2, you get to enjoy enterprise Linux without the hassle of managing two systems.

** Svensk version – Swedish version below
**

Red Hat Unwrapped #2: Att Köra RHEL på Windows med WSL 2

Välkommen tillbaka till Red Hat Unwrapped-serien! I första kapitlet utforskade vi Linux-grunder och RHELs roll i företagsvärlden. Nu går vi från teori till praktik – genom att integrera RHEL direkt i din Windows-miljö med Windows Subsystem for Linux 2 (WSL 2).

🚀 Varför Använda RHEL på WSL 2?

✅ Sömlös Integration: Kör RHEL sida vid sida med dina Windows-appar utan att behöva ändra partitioner, dubbla uppstarter eller separata virtuella maskiner.

⚡ Effektiv Utveckling: Bygg och testa Linux-applikationer direkt på Windows för ett smidigare arbetsflöde, perfekt för utvecklare som växlar mellan miljöer.

📦 Åtkomst till Enterprise-verktyg: Använd RHEL:s kraftfulla paketstyrning och verktyg av företagsklass direkt på din Windows-dator.

📌 Hur Man Installerar RHEL på WSL 2

1️⃣ Aktivera WSL 2

Öppna PowerShell som administratör.

Kör följande kommandon:

wsl --install
wsl --set-default-version 2

2️⃣ Ladda ner RHEL WSL Image

Besök Red Hat Customer Portal.

Gå till nedladdningssektionen och hämta RHEL WSL-bilden (vanligtvis en .tar-fil).

3️⃣ Importera RHEL Image till WSL

wsl --import RHEL C:\WSL\RHEL C:\Path\To\Downloaded\RedHat.tar --version 2

4️⃣ Starta Din RHEL-instans

wsl -d RHEL

5️⃣ Registrera och Uppdatera RHEL

Inuti RHEL-miljön, kör:

sudo subscription-manager register --username --password
sudo subscription-manager attach --auto
sudo dnf update -y

🎯 Varför Denna Setup är Utmärkt

🌐 Enhetligt Arbetsflöde: Utveckla, testa och distribuera Linux-applikationer utan att lämna din Windows-miljö.

🚀 Lätt och Snabb: WSL 2 använder mindre systemresurser än en fullständig virtuell maskin.

⚡ Ökad Produktivitet: Växla sömlöst mellan Windows- och Linux-verktyg.

Genom att installera RHEL på WSL 2 kombinerar du kraften hos företags-Linux med flexibiliteten hos Windows. Håll utkik efter fler inlägg i Red Hat Unwrapped-serien!

Red Hat Unwrapped: A Beginner's Journey into Enterprise Linux #1

Hamed0406 — Wed, 23 Apr 2025 11:37:24 +0000

🐧 Red Hat Unwrapped – Chapter 1: What Is Linux & Why Should You Care?
Linux is more than just an operating system—it's the foundation of modern computing. From powering websites and smartphones to supercomputers and cloud platforms, Linux is everywhere. But what exactly makes it so important, especially for IT professionals?

🔍 What Is Linux?
Linux is an open source, Unix-like operating system. At its core is the Linux kernel, developed in 1991 by Linus Torvalds. Around this core, Linux distributions (or "distros") package software and tools to create full operating systems like Ubuntu, Fedora, or Red Hat Enterprise Linux (RHEL).

💡 Why Should You Learn Linux?
Linux is essential in:

Web hosting & cloud computing (AWS, Azure, GCP)

App development and DevOps workflows

IoT devices and mobile OS backends (like Android)

Enterprise systems and data centers

Knowing Linux is like having a key to modern tech infrastructure.

🛠️ What Makes Linux Special?
Open Source: Anyone can view, modify, and share the code.

CLI-first Design: Powerful automation and scripting via terminal.

Modular Architecture: Customize and adapt components easily.

🔓 What Is Open Source?
Open source software allows anyone to:

Access the source code

Modify and improve it

Share it with others—royalty-free

It fosters innovation, security, and collaboration. Licenses like GPL (Copyleft) and MIT (Permissive) shape how open source can be reused.

📦 What Is a Linux Distribution?
A Linux distro includes:

The Linux kernel

Software utilities (e.g., Bash, systemd)

Tools for installation and updates

Popular distros include Ubuntu, Fedora, and Red Hat Enterprise Linux (RHEL).

🧠 Meet Red Hat
Red Hat is a major open source leader. Their flagship product, RHEL, is a stable, enterprise-grade Linux distro. It evolves through:

🚀 Fedora – experimental and cutting-edge

🔁 CentOS Stream – continuous integration, RHEL preview

✅ RHEL – hardened, supported, and ready for production

This ecosystem ensures that features are tested and refined before reaching enterprise users.

📤 Ways to Get RHEL

🆓 RHEL Evaluation

🧪 Developer Subscription (Free)

☁️ Cloud Platforms

🧱 UBI Containers

🔁 CentOS Stream

🐧 Fedora Project

📦 EPEL Docs

📝 Summary
Linux is a vital, open source OS powering global infrastructure.

Red Hat leads in enterprise Linux with a community-driven approach.

The RHEL development model is now more transparent, open, and continuous through Fedora → CentOS Stream → RHEL.

** Svensk version – Swedish version below
**

Vad är Linux – och varför ska du bry dig?
Välkommen till det första kapitlet i Red Hat Unwrapped, en nybörjarvänlig serie som guidar dig genom Linux, öppen källkod och företagsklassad teknik med Red Hat.

🧠 Vad är Linux?
Linux är ett operativsystem med öppen källkod, byggt kring en kärna som utvecklades av Linus Torvalds 1991. Det driver:

Webbservrar

Android-mobiler

Molnplattformar som AWS, Azure och Google Cloud

Superdatorer

Finansiella system

Det finns många olika varianter – kallade distributioner – till exempel Ubuntu, Debian, Fedora och Red Hat Enterprise Linux (RHEL).

🚀 Varför lära sig Linux?
Att kunna Linux öppnar dörrar till yrkesroller som:

Systemadministratör

DevOps-ingenjör

Molnspecialist

Cybersäkerhetsexpert

Inom IT- och teknikvärlden är Linux inte längre ett alternativ – det är en grundförutsättning.

🔓 Vad gör Linux speciellt?
Öppen källkod – frihet att se, ändra och bidra till koden

CLI-fokus – kraftfull kommandoradsbaserad hantering

Flexibilitet – du bygger system som passar dina behov

💡 Vad är öppen källkod?
Öppen källkod är mer än gratis kod. Det handlar om:

Samarbete över hela världen

Transparent och säker utveckling

Gemenskaper som bygger tillsammans

Licenser som främjar frihet (GPL, MIT, Apache m.fl.)

Red Hat är en nyckelspelare i det öppna ekosystemet.

🛠 Vad är en Linux-distribution?
En distribution är ett komplett operativsystem som inkluderar Linux-kärnan, verktyg och användargränssnitt. Exempel:

Fedora – innovationsfokuserad

CentOS Stream – rullande förhandsvisning av RHEL

RHEL – stabil, säker och redo för företag

👩‍💻 Vem är Red Hat?
Red Hat är ett av världens mest inflytelserika företag inom öppen källkod. De utvecklar RHEL – ett system som används globalt inom finans, sjukvård, utbildning och molninfrastruktur.

De står också bakom:

Fedora – community och innovation

CentOS Stream – vägen till RHEL

OpenShift – plattform för containers och Kubernetes

🔄 Hur utvecklas Red Hat Enterprise Linux?
Red Hats utvecklingsmodell:

Fedora – testbädd för ny teknik

CentOS Stream – kontinuerlig leverans inför nästa RHEL-version

RHEL – företagssäker, långsiktigt underhållen

Why Consider NixOS for Your Environment?

Hamed0406 — Tue, 27 Aug 2024 11:45:48 +0000

Why Consider NixOS for Your Environment?

When managing environments—whether for development, testing, or production—choosing the right tools is crucial. NixOS, a unique Linux distribution, offers several advantages that make it a strong contender in certain scenarios, especially when compared to more traditional systems and modern orchestration tools like Kubernetes and OpenShift. In this post, we'll explore what NixOS is, why you might choose it over other options like Docker, Kubernetes, or OpenShift, and how it can be particularly effective in managing ephemeral environments.

What is NixOS?

NixOS is a Linux distribution built around the Nix package manager, which employs a purely functional approach to package management and system configuration. With NixOS, you can define your entire system declaratively, ensuring that environments are reproducible and consistent across different machines.

Key Features of NixOS:

Declarative Configuration: Everything from installed packages to system services is defined in a single configuration file.
Reproducibility: NixOS ensures environments can be reproduced exactly, avoiding the typical "it works on my machine" issues.
Atomic Upgrades and Rollbacks: Perform system upgrades or rollbacks with guaranteed consistency.
Isolation and Immutability: Dependencies are managed in isolated environments, preventing conflicts and ensuring multiple versions of packages can coexist without issues.

Why Use NixOS?

If you're considering using NixOS, it’s likely because you need a system that prioritizes control, reproducibility, and safe upgrades. Here’s why NixOS might be the right choice for your environment:

Reproducibility and Consistency:

NixOS provides absolute reproducibility of environments. The entire system state is declared in configuration files, ensuring that any machine set up with the same configuration behaves identically.

Safe and Reliable Upgrades:

NixOS supports atomic upgrades and rollbacks, reducing the risk of breaking your environment during updates.

Full System Control:

Manage the entire system configuration with NixOS, not just applications. This level of control is beneficial for environments that require customization at every level.

Isolation of Dependencies:

NixOS’s package management system handles dependencies robustly, reducing the risk of conflicts.

Flexibility and Customization:

NixOS is highly customizable, allowing you to build environments tailored to your specific needs—whether for development, production, or testing.

NixOS vs. Docker

Docker is a widely-used tool for containerization, offering a convenient way to package and deploy applications. However, NixOS provides advantages that might make it a better choice in certain scenarios:

Reproducibility:

While Docker images can be reproducible, NixOS offers stronger guarantees due to its purely functional approach.
System Configuration:

NixOS manages the entire operating system declaratively, whereas Docker focuses more on the application layer.

Dependency Management:

NixOS’s package management system handles dependencies more effectively, reducing the risk of conflicts.

Efficiency:

NixOS environments can be more resource-efficient than a full Docker setup, especially if containerization is unnecessary.

Atomic Rollbacks:

NixOS’s ability to rollback system states provides safety and stability in environments where uptime is critical.

NixOS as an Ephemeral Environment

Ephemeral environments—created, used, and discarded as needed—are often used in CI/CD pipelines, testing, and development. NixOS is particularly well-suited for managing these types of environments:

Declarative Setup:

Define your entire ephemeral environment in a Nix configuration file, ensuring consistency and reproducibility.

Isolation:

NixOS’s package management ensures environments are isolated, preventing changes in one environment from affecting others.

Fast Provisioning:

With tools like NixOps or Docker containers based on NixOS, you can quickly spin up and tear down environments.

Efficient Resource Usage:

NixOS environments are minimal, including only the necessary dependencies—ideal for ephemeral use cases.

NixOS vs. Kubernetes and OpenShift

Kubernetes and OpenShift are powerful platforms for container orchestration, particularly in multi-node, distributed environments. However, NixOS offers benefits in scenarios where full-scale container orchestration might be overkill:

Simplicity:

NixOS is simpler to manage compared to Kubernetes and OpenShift, which require significant resources and expertise.

Full System Control:

NixOS manages the entire system, including the operating system—something Kubernetes and OpenShift don’t focus on.

Resource Efficiency:

NixOS can be more resource-efficient in single-node or simple deployments, where the overhead of Kubernetes/OpenShift is unnecessary.

Reproducibility:

While Kubernetes/OpenShift focuses on application-level reproducibility, NixOS ensures reproducibility at the system level.

Customization:

NixOS offers more flexibility in customizing the operating system environment, making it ideal for scenarios requiring more than just container orchestration.

Use Cases Beyond Containerization:

If your applications are not containerized or if you have legacy systems that are difficult to containerize, NixOS may be a better fit.
When to Choose NixOS?
You might choose NixOS over Docker, Kubernetes, or OpenShift if:

You need absolute reproducibility across environments, not just for applications but for the entire system.
Control and customization of the operating system are critical.
Resource efficiency and simplicity are more important than distributed orchestration features.
Non-containerized applications or legacy systems need to be managed alongside modern software.
You prefer a declarative approach to system configuration that integrates all aspects of the environment into a single, manageable format.

Conclusion

NixOS is a powerful tool for those who prioritize reproducibility, control, and simplicity in their computing environments. While Kubernetes, OpenShift, and Docker each have their strengths, NixOS offers a unique approach that is particularly well-suited for environments where full system control, reproducibility, and efficiency are paramount. Whether you're managing ephemeral environments, looking for a robust alternative to traditional containerization, or simply want a highly customizable and reliable operating system, NixOS provides compelling advantages worth considering.

How to change place of saving models on ollama

Hamed0406 — Tue, 30 Jul 2024 07:58:14 +0000

To change the default location where Ollama saves its models, you need to set an environment variable called OLLAMA_MODELS to the desired directory. Here's how you can do it on different operating systems:

Windows
Open Environment Variables:

Press Win + X and select System.

In the System window, click on Advanced system settings on the left sidebar.
In the System Properties window, click on the Environment Variables... button.

Create a New Environment Variable:

In the Environment Variables window, look for the System variables section and click on New....
Enter OLLAMA_MODELS for the Variable name.
Enter the path where you want to save the model files for the Variable value (e.g., D:\OllamaModels).
Click OK to save the new environment variable.

Restart Ollama:

Quit Ollama if it's running.
Restart Ollama to ensure it recognizes the new environment variable.

Verify the New Location:

Download a new model and check if it is saved in the new directory (e.g., D:\OllamaModels\models\blobs).

Linux

Edit Systemd Service:

Open a terminal and run systemctl edit ollama.service.
Add the line Environment="OLLAMA_MODELS=/path/to/new/location" under the [Service] section.
Save and exit the editor.

Reload and Restart:

Run systemctl daemon-reload.
Restart Ollama with systemctl restart ollama.

macOS

Set Environment Variable:

Open a terminal and use the command launchctl setenv OLLAMA_MODELS /path/to/new/location.
Restart the Ollama application to apply the changes.

If the environment variable approach does not work, another method is to create a symbolic link (symlink) or use a bind mount (on Linux). This involves moving the models directory to the new location and linking it back to the original path, ensuring Ollama can still find the models without needing to be reconfigured.

For detailed steps and troubleshooting, you can refer to the official documentation and community solutions:

GitHub Issue Discussions: GitHub
Step-by-step guide: SkillsFoster
Bind Mount for Linux: Arch Linux Forums

Effortlessly Retrieve Data from Azure Blob Storage with PowerShell

Hamed0406 — Wed, 03 Apr 2024 10:58:45 +0000

Why is a PowerShell script beneficial for interacting with Azure Blobs?

Streamlines processes by leveraging the Azure REST API for automation.
Seamlessly integrates with Azure Functions for enhanced cloud functionality.
Utilizes standard HTTP/HTTPS protocols for secure and reliable downloads from Azure Blob Storage.

here is script

Link to the repo

This PowerShell script is designed to interact with Azure Blob Storage by retrieving a list of blob items from a given storage container and then, optionally, downloading those items to a local directory. The script is divided into two main functions: Get-BlobItems and Invoke-BlobItems. Both functions require a URL to the Blob Storage container as a parameter, which must include a Shared Access Signature (SAS) token for authentication.

Function 1: Get-BlobItems

The Get-BlobItems function's primary purpose is to list all the blob items within a specified Azure Blob Storage container.

1.Splitting the URL: It begins by splitting the input URL into two parts: the base URI and the SAS token. This is necessary because the SAS token is used for authenticated access, and the base URI identifies the storage container.

2.Creating a New URL for the API Request: It then constructs a new URL that includes the base URI, a query to list the blobs (restype=container&comp=list), and the SAS token. This URL is used to make a REST API call to Azure Blob Storage.

**3.Invoking the REST API: **The script uses Invoke-RestMethod to call the Azure REST API with the newly constructed URL. The response is expected to be in XML format, listing all blobs within the container.

4.Processing the XML Response: The XML response is parsed to extract the names of the blob items. These names are relative paths to the blobs within the storage container.

5.Download URLs: For each blob item, a download URL is generated by combining the base URI, the blob item's name, and the SAS token. These URLs can be used to download the blob items directly.

Function 2: Invoke-BlobItems

The Invoke-BlobItems function extends the capabilities of Get-BlobItems by not only listing the blob items but also downloading them to a specified local path.

1.URL Splitting and API Request URL Construction: This part is identical to the Get-BlobItems function, where the function splits the input URL and constructs a new URL to invoke the Azure REST API for listing blobs.

2.XML Response Handling and Blob Listing: The response from the Azure REST API is processed in the same way, extracting the names of the blob items from the XML.

3.Downloading Blob Items: For each blob item listed in the XML response, the function checks if the local directory structure exists (based on the blob's relative path) and creates it if necessary. It then uses System.Net.WebClient to download each blob item to the specified local directory, constructing the full download URL for each item using the base URI, blob name, and SAS token.

Illustrative Diagram

To better understand the flow and components of the script, let's visualize the process with a diagram:

1.Input: The user provides a URL containing the base URI to the Blob Storage container and a SAS token for authentication.
2.URL Processing: The script splits the URL to extract the base URI and SAS token, then constructs a new URL for the REST API call.
3.API Call: A REST API request is made to Azure Blob Storage to list the blobs in the container.
4.Response Handling: The XML response is parsed to extract the names of the blobs.
5.Download URL Generation: For each blob, a download URL is generated.
6.File Download: In the Invoke-BlobItems function, the blobs are downloaded to a specified local directory.
The user inputs a URL with a SAS token.
The script processes this URL, separating the base URI and the SAS token.
A REST API call is made to list the blobs in the container.
The blobs are listed and optionally downloaded to a local directory.

Happy coding , until next time !

Transitioning from Java to .NET as Java Developer

Hamed0406 — Wed, 13 Mar 2024 14:10:43 +0000

If you are Java developer and you want to move to .NET this list is for you .

Transitioning from Java to .NET can be a smooth process, especially with your background in programming and understanding of object-oriented concepts. Here are some steps and resources to help you get started with .NET development:

1. Understand the .NET Ecosystem

.NET Framework vs .NET Core vs .NET 5/6/7+: Understand the differences between these platforms. .NET Core and its successor, .NET 5/6/7+, are cross-platform, supporting Windows, Linux, and macOS, which is likely more appealing to someone with a Java background.
Languages: C# is the most popular language for .NET development, but you can also use F# for functional programming or VB.NET.

2. Set Up Your Development Environment

Install Visual Studio: For Windows developers, Visual Studio is the most powerful IDE for .NET development. Visual Studio Community is free for individual developers, open-source projects, academic research, and small professional teams.
Visual Studio Code: If you prefer a lightweight editor that is also powerful and cross-platform, Visual Studio Code is a great option. It supports C#, F#, and VB.NET through extensions.
.NET SDK: Ensure you have the latest .NET SDK (Software Development Kit) installed for developing .NET applications.

3. Learn C

Official Documentation: Start with Microsoft's official documentation for C#. It's comprehensive and includes tutorials for both beginners and experienced developers.
Online Courses: Platforms like Pluralsight, Udemy, and Coursera offer courses on C# and .NET development. Many of these are created by industry experts.
Books: Books like "C# 9.0 in a Nutshell" and "Pro C# 8 with .NET Core 3" are great for beginners and experienced developers alike.

4. Build Projects

Start Simple: Begin with console applications to understand syntax and basic concepts like loops, conditionals, and data types.
Move to Web or Desktop Applications: Use ASP.NET Core for web development. For desktop applications, consider Windows Forms or WPF (Windows Presentation Foundation) if you're focusing on Windows. For cross-platform GUI, you can explore MAUI or Avalonia.

Explore .NET Libraries and Frameworks Entity Framework: Learn about Entity Framework for data access. ASP.NET Core: Dive into web development with ASP.NET Core, which supports building web apps and APIs. Blazor: For SPA (Single Page Application) fans coming from a Java/JavaScript background, Blazor allows you to build interactive web UIs using C# instead of JavaScript.

6. Join the Community

Forums and Social Media: Platforms like Stack Overflow, Reddit, and Twitter are great places to ask questions and connect with other developers.
GitHub: Explore open-source .NET projects to see how others structure their applications and solve common problems.
Transitioning to a new development ecosystem can be challenging but rewarding. Your experience as a Java developer will definitely give you a solid foundation, especially in understanding object-oriented programming, which is a core concept in .NET development. Happy coding!

Microsoft Entra ID

Hamed0406 — Wed, 07 Feb 2024 20:57:22 +0000

Microsoft Entra is a suite of identity and access management solutions designed to secure access for every user, application, and device within an organization. As of my last update in April 2023, Microsoft Entra includes various components aimed at enhancing security and simplifying identity management across a range of scenarios, from cloud services to hybrid environments.

The term "Microsoft Entra ID" could refer to the identities managed within the Microsoft Entra ecosystem, particularly focusing on how individual users are identified, authenticated, and authorized to access resources and applications. In the broader context, Microsoft Entra helps manage and secure user identities with services like:

Microsoft Azure Active Directory (Azure AD): Azure AD is the cloud-based identity and access management service, which is a core component of Microsoft Entra. It enables Single Sign-On (SSO), multi-factor authentication (MFA), and conditional access policies among other features.
Microsoft Entra Verified ID: This is a service within Microsoft Entra that focuses on decentralized identity verification, allowing individuals and organizations to own and control their digital identities without relying on a central authority.
Microsoft Entra Permissions Management: Formerly known as CloudKnox, this component offers visibility and control over permissions and actions across your cloud infrastructure.
Microsoft Entra Workload Identities: This service is focused on managing and securing non-human identities used by applications, services, and workloads that require access to resources.

Together, these services under the Microsoft Entra umbrella work to ensure that identities, whether they belong to human users or are workload identities used by applications and services, are securely managed and authenticated.

Git Tools - Submodules

Hamed0406 — Mon, 28 Nov 2022 12:13:35 +0000

What is Submodules and why developer need it ?

Git Tools - Submodules is tools to let developer have a child repository under a parent repository .

in other words as git official document said :
"Submodules allow you to keep a Git repository as a subdirectory of another Git repository. This lets you clone another repository into your project and keep your commits separate." [1]

configuration file for Git-Submodules is ".gitmodules" .
The new submodule can be added by this command :

git submodule add the absolute or relative URL of the project

for example :

git submodule add https://gitlab.com/Hamed0406/springboot-dashboed
after running the command this lines will be added to

[submodule "springboot-dashboed"]
    path = springboot-dashboed
    url = https://gitlab.com/Hamed0406/springboot-dashboed

to .gitmodules file.

Note : if you have private repo as submodules and share your project with others, you have to be sure they have access to the private repo.

References

git-scm.com , [https://git-scm.com/book/en/v2/Git-Tools-Submodules]

Free Badge/certification

Hamed0406 — Mon, 07 Nov 2022 14:37:49 +0000

In this post I share some information about difference free certification and badge:

Become an OCI Foundations Associate Become an OCI Foundations Associate Last check 2022-11-07

Become an Oracle Cloud Data Management Foundations Associate Become an Oracle Cloud Data Management Foundations Associate Last check 2022-11-07

Container Technology

Hamed0406 — Sun, 06 Nov 2022 18:32:17 +0000

Containerized Applications

Software applications typically depend on other libraries, configuration files, or services that are provided by the runtime environment. The traditional runtime environment for a software application is a physical host or virtual machine, and application dependencies are installed as part of the host.

For example, consider a Python application that requires access to a common shared library that implements the TLS protocol. Traditionally, a system administrator installs the required package that provides the shared library before installing the Python application.

The major drawback to a traditionally deployed software application is that the application’s dependencies are closely related to the runtime environment.

An application may break when any updates or patches are applied to the base operating system (OS).

For example, an OS update to the TLS shared library removes TLS 1.0 as a supported protocol. This breaks the deployed Python application because it is written to use the TLS 1.0 protocol for network requests. This forces the system administrator to roll back the OS update to keep the application running, preventing other applications from using the benefits of the updated package.

Therefore, a company developing traditional software applications may require a full set of tests to guarantee that an OS update does not affect applications running on the host.

Furthermore, a traditionally deployed application must be stopped before updating the associated dependencies. To minimize application downtime, organizations design and implement complex systems to provide high availability of their applications. Maintaining multiple applications on a single host often becomes cumbersome, and any deployment or update has the potential to break one of the organization’s applications.

Alternatively, a software application can be deployed using a container.

A container is a set of one or more processes that are isolated from the rest of the system.

Containers provide many of the same benefits as virtual machines, such as security, storage, and network isolation. Containers require far fewer hardware resources and are quick to start and terminate. They also isolate the libraries and the runtime resources (such as CPU and storage) for an application to minimize the impact of any OS update to the host OS, as described in Figure 1.1: Container versus operating system differences.

Figure 1.1

The use of containers not only helps with the efficiency, elasticity, and reusability of the hosted applications, but also with application portability. The Open Container Initiative (OCI) provides a set of industry standards that define a container runtime specification and a container image specification. The image specification defines the format for the bundle of files and metadata that form a container image. When you build an application as a container image, which complies with the OCI standard, you can use any OCI-compliant container engine to execute the application.

The following are other major advantages to using containers:

Low hardware footprint

Containers use OS internal features to create an isolated environment where resources are managed using OS facilities such as namespaces and cgroups (control groups). This approach minimizes the amount of CPU and memory overhead compared to a virtual machine hypervisor. Running an application in a VM is a way to create isolation from the running environment, but it requires a heavy layer of services to support the same low hardware footprint isolation provided by containers.

Environment isolation

Containers work in a closed environment where changes made to the host OS or other applications do not affect the container. Because the libraries needed by a container are self-contained, the application can run without disruption. For example, each application can exist in its own container with its own set of libraries. An update made to one container does not affect other containers.

Quick deployment

Containers deploy quickly because there is no need to install the entire underlying operating system. Normally, to support the isolation, a new OS installation is required on a physical host or VM, and any simple update might require a full OS restart. A container restart does not require stopping any services on the host OS.

Multiple environment deployment

In a traditional deployment scenario using a single host, any environment differences could break the application. Using containers, however, all application dependencies and environment settings are encapsulated in the container image.

Reusability

The same container can be reused without the need to set up a full OS. For example, the same database container that provides a production database service can be used by each developer to create a development database during application development. Using containers, there is no longer a need to maintain separate production and development database servers. A single container image is used to create instances of the database service.

Often, a software application with all of its dependent services (databases, messaging, file systems) are made to run in a single container. This can lead to the same problems associated with traditional software deployments to virtual machines or physical hosts. In these instances, a multicontainer deployment may be more suitable.

Furthermore, containers are an ideal approach when using microservices for application development. Each service is encapsulated in a lightweight and reliable container environment that can be deployed to a production or development environment. The collection of containerized services required by an application can be hosted on a single machine, removing the need to manage a machine for each service.

In contrast, many applications are not well suited for a containerized environment. For example, applications accessing low-level hardware information, such as memory, file systems, and devices might be unreliable due to container limitations.

Refences

opencontainers
Red Hat OpenShift I:Containers & Kubernetes By Red Hat chapter 1
Image cover

Linux Automation - Centralized Logging

Hamed0406 — Mon, 24 Oct 2022 09:44:48 +0000

In this tutorial , I teach you how to use Rsyslog to configure central-log server on CentOS 7 / RHEL 7.
Why we need logging ?
To find out what's happing on the system/find proper solation to a problem .

All commands should be run as root user.

1- Configure Server side

To install Rsyslog package , if you don't have it :

yum -y install rsyslog

configurations file for syslog is located on /etc/rsyslog.conf .
Use your favorite file editor to edit rsyslog.conf and uncomment follows lines :

Provides UDP syslog receptio

$ModLoad imudp
$UDPServerRun 514

Restart the rsyslog service once your changes have been saved.

systemctl restart rsyslog

Verifying syslog server listening on the port 514

netstat -antup | grep 514
Output should be like this :

udp 0 0 0.0.0.0:514 0.0.0.0:* 1467/rsyslog udp6 0 0 :::514 :::* 1467/rsyslogdd

If you have firewall on host server ,you need to enable inbound port 514/UDP

Enabling firewall inbound port TCP

firewall-cmd --permanent --add-port=514/tc firewall-cmd --reloadp

Enabling firewall inbound port UDP

firewall-cmd --permanent --add-port=514/ud firewall-cmd --reloadp

2- Configure client side

Install rsyslog package on client , if it is not installed .

configure client by editing /etc/rsyslog.conf by Add the following logging rule below the "RULES" line and restart the rsyslog service.
*.info,@NameOfYourServer/IPAdressFQDN
Restart the rsyslog service once your changes have been saved.
Now all log messages of info priority or higher appear in /var/log/messages on Log-server.
Thank you for reading and have happy coding.