What Are Permissions?

Permissions are critical components in computer systems, applications, and networks that define what actions a user or a group of users can perform on a specific resource. These resources could be anything from files and directories to network services and databases. Permissions serve as a security mechanism that helps control access and ensure the integrity of data and functionality within the system.

In computing, permissions are typically assigned to specific user accounts, groups, or roles and are associated with resources (e.g., files, folders, network services). The specific actions that can be performed on a resource might include reading, writing, executing, or deleting.

Permissions are implemented in different ways, depending on the operating system or platform, but they all aim to secure and govern the usage of system resources. By controlling who can access a resource and what operations they can perform, permissions prevent unauthorized access and safeguard sensitive data.

Types of Permissions:

1. Read (r): Allows the user to view the contents of a file or directory.
2. Write (w): Allows the user to modify or write to a file or directory.
3. Execute (x): Allows the user to run a file as a program or execute scripts.
4. Delete: Allows the user to remove a file or directory from the system.
5. Full Control: Grants all the above permissions along with the ability to modify permissions for files and directories.
6. Special Permissions: In systems like UNIX/Linux, advanced permissions can be set, such as the setuid or sticky bit.

Permissions can be set on different levels: for individual users, user groups, or others (i.e., anyone who is not the owner or part of the group).

What Are the Major Use Cases of Permissions?

Permissions are utilized across various computing environments to control access to sensitive resources and ensure system security. Here are some major use cases:

1. File System Security

• Use Case: Permissions are commonly used in operating systems to restrict access to files and directories. They determine who can read, write, or execute files within a system. This prevents unauthorized access to critical files or modifications by users without proper authorization.
• Example: In Linux/Unix systems, file permissions are assigned using chmod (change mode) to specify who can access and modify the file. For example, the command chmod 755 filename grants the owner read/write/execute permissions, while granting read/execute permissions to others.
• Example: In Windows, permissions for files or folders can be set through the Properties menu, where an administrator can specify who can access files and what actions they can perform.

2. Database Access Control

• Use Case: Permissions are essential for controlling access to databases. In Relational Database Management Systems (RDBMS), such as MySQL, PostgreSQL, and SQL Server, permissions are used to restrict or allow specific operations (e.g., select, insert, update, delete) on database tables.
• Example: A database administrator (DBA) might grant read-only permissions to users accessing reporting tables while restricting others from making changes to the data.
• Example:

GRANT SELECT, INSERT, UPDATE ON users TO 'employee_role';

3. Cloud Services and Resources

• Use Case: In cloud computing, permissions are used to manage access to cloud resources such as compute instances, storage buckets, and databases. Permissions control who can launch, terminate, scale, or monitor cloud resources.
• Example: In Amazon Web Services (AWS), IAM (Identity and Access Management) roles and policies are used to grant permissions to users and services. A developer might have full permissions to access EC2 instances but only read access to S3 buckets.
• Example: In Google Cloud Platform (GCP), access permissions for Google Cloud Storage (GCS) buckets can be set using IAM roles to restrict who can upload, download, or delete objects from a bucket.

4. Network Access Control

• Use Case: Permissions play a vital role in controlling access to network resources, such as shared folders, printers, and network devices. Access control lists (ACLs) are commonly used to define who can connect to network resources.
• Example: In Windows Server environments, network ACLs are used to grant or deny access to network shares based on user roles or IP addresses.
• Example: A firewall might use ACLs to allow traffic from specific IP addresses while blocking others from accessing certain internal servers.

5. Application-Level Access Control

• Use Case: Many applications, including web applications, use permission systems to control user access. Applications often implement role-based access control (RBAC) to manage which users can perform specific tasks.
• Example: In a content management system (CMS), administrators may be granted permissions to create, update, or delete content, while regular users only have permission to view content.
• Example: A social media platform might use permissions to control who can see a user’s profile, post content, or comment.

6. Role-Based Access Control (RBAC)

• Use Case: RBAC is a permission model where access is granted based on the roles assigned to users. Roles define the set of permissions associated with them, making it easier to manage access at scale.
• Example: A company might have roles such as admin, manager, and employee, each with different access levels to systems and data. An admin would have full control over the system, while an employee might have read-only access.

How Permissions Work Along with Architecture?

Permissions are a critical component in the security architecture of systems. Their primary function is to ensure that only authorized users can access or modify specific resources. Here’s how permissions integrate with system architecture:

1. Role-Based Access Control (RBAC)

• RBAC is a common way to manage permissions in large systems. In RBAC, users are assigned roles that correspond to a set of permissions. Each role defines the actions that a user can or cannot perform on specific resources.
• For example, in a web application, roles like Admin, Editor, and Viewer might have different permissions to access, modify, or delete content.

2. Access Control Lists (ACLs)

• ACLs are used to define the permissions for each user or group on a specific resource (such as files, network shares, or database objects). Each entry in an ACL specifies a user or group and the permissions they have (e.g., read, write, execute).
• Example: A file system on Linux uses ACLs to determine which users or groups can access a file, and what operations (read, write, execute) they are permitted to perform.

3. Authentication and Authorization

• Permissions are typically enforced after a user has been authenticated. Authentication ensures that the user is who they claim to be, while authorization determines what resources they are allowed to access and what actions they can perform.
• Example: In an enterprise environment, an employee might authenticate using single sign-on (SSO), and the system will then check their role and permissions to determine which applications and resources they can access.

4. File and Directory Permissions

• In operating systems like Linux, UNIX, and Windows, permissions are set on files and directories to control which users or groups can read, write, or execute the file.
• Linux Example: File permissions can be set using the chmod command, which grants read, write, or execute access to a file for the owner, group, or others.

5. Cloud and Web Services

• Cloud services use Identity and Access Management (IAM) systems to manage who has access to cloud resources and what actions they can perform. IAM is built on a role-based model where users are assigned roles with specific permissions.
• AWS IAM is a prime example of how cloud services use roles, groups, and policies to manage permissions across cloud resources.

What Are the Basic Workflow of Permissions?

The basic workflow of permissions typically involves defining users and resources, assigning permissions, and enforcing those permissions across the system. Here’s a typical workflow:

Step 1: Define Users and Roles

• Identify the users who need access to the system and define roles based on the tasks and responsibilities associated with each user.
• Example: Administrator, Manager, and Employee roles.

Step 2: Define Resources

• Identify the resources (files, databases, network services) that need access control. Resources can vary from files in a file system to cloud services or databases.
• Example: A shared folder in a network, HR database, or email system.

Step 3: Assign Permissions

• Assign permissions to users or roles for each resource. Permissions define what actions (read, write, execute, delete) users or roles can perform on a resource.
• Example: An Admin role might have full access to all files, while an Employee role might have read-only access.

Step 4: Enforce Access Control

• The system enforces the permissions by checking if the user or role is authorized to perform the requested operation. If the user has the correct permissions, the action is allowed; otherwise, it is denied.
• Example: In UNIX, file permissions determine whether a user can read, write, or execute a file.

Step 5: Audit and Monitor Permissions

• Systems can track who accessed a resource and what actions they performed. This is important for compliance, security auditing, and forensic analysis.
• Example: Windows Server and Linux systems log access events that can be reviewed later.

Step-by-Step Getting Started Guide for Permissions

Step 1: Identify Resources

• Determine which resources need to be secured (files, network shares, databases, applications).

Step 2: Create User Accounts or Roles

• Create user accounts or define roles based on the required level of access. Assign users to appropriate roles (e.g., Admin, User, Guest).

Step 3: Assign Permissions

• Assign the necessary permissions to resources for each user or role. Use ACLs, RBAC, or IAM systems depending on the environment.
• Example for Linux:

chmod 755 file.txt

Step 4: Enforce Access Control

• Implement access control policies at the file system, database, or application level to ensure that only authorized users can access resources.

Step 5: Monitor and Audit

• Use monitoring tools to track access and ensure compliance with security policies.

The post Permissions: Comprehensive Guide for Securing Resources and Managing Access appeared first on scmGalaxy.

What is Raspberry Pi?

The Raspberry Pi is a small, affordable, single-board computer that has gained immense popularity for its versatility, low-cost nature, and ease of use. It was developed by the Raspberry Pi Foundation, a UK-based charity with the goal of encouraging the study of computer science and electronics in schools and in developing countries. Since its launch in 2012, Raspberry Pi has become a key tool in education, hobbyist projects, and industrial applications due to its accessibility, performance, and adaptability.

The Raspberry Pi runs a variety of operating systems, including Raspberry Pi OS (formerly Raspbian), a Linux-based OS that is optimized for the hardware. It’s an excellent platform for learning programming, experimenting with electronics, and building diverse projects, from home automation to robotics.

The core feature of the Raspberry Pi is its compact form factor, which makes it portable and highly adaptable. Despite its small size, the Raspberry Pi is a full-fledged computer capable of running word processors, web browsers, and even media centers. With built-in features such as GPIO pins for physical computing projects, HDMI outputs for video, USB ports for peripherals, and support for Wi-Fi and Bluetooth, Raspberry Pi is truly a multifunctional device.

Core Features of Raspberry Pi:

• Low-Cost: The Raspberry Pi is extremely affordable, with prices starting at as low as $5 for the Raspberry Pi Zero model.
• Compact Size: The board measures approximately the size of a credit card, making it easy to use in space-constrained projects.
• Versatility: Raspberry Pi can serve as a desktop computer, a media center, a development board, a server, or a part of complex systems like IoT devices and robotics.
• Extensibility: With GPIO pins, USB ports, HDMI outputs, and Ethernet/Wi-Fi capabilities, Raspberry Pi is widely used for embedded projects, creating custom computers, servers, and hardware integrations.
• Programming Flexibility: Raspberry Pi supports a variety of programming languages like Python, JavaScript, C/C++, and Java, among others.
• Open-Source: Raspberry Pi is supported by a large open-source community, and it runs on Raspberry Pi OS, an open-source Linux-based operating system.

What Are the Major Use Cases of Raspberry Pi?

Raspberry Pi has found applications in numerous fields due to its flexibility, affordability, and performance. Below are some of the most prominent use cases:

1. Educational Use in Schools and Universities

• Use Case: Raspberry Pi was initially created to promote computer science and electronics education. It is commonly used in schools and universities to teach programming and hardware design.
• Example: Raspberry Pi is used to teach students about coding, basic electronics, and the principles of computer architecture. Through hands-on projects, students can create simple systems and gain practical knowledge.
• Example: Raspberry Pi is also used to introduce programming languages like Python and Scratch to young learners, making it easier for them to learn logic and computational thinking.

2. IoT (Internet of Things) and Automation

• Use Case: Raspberry Pi is a popular platform for building Internet of Things (IoT) devices and systems. Its GPIO pins allow it to interface with sensors, actuators, and other physical devices, making it suitable for smart home automation projects, sensor networks, and more.
• Example: Raspberry Pi can be used in a smart home setup to control lighting, security systems, temperature, and other devices. With appropriate sensors and software, Raspberry Pi can automate actions based on user preferences or sensor data.

3. Media Center and Home Theater Systems

• Use Case: Raspberry Pi is widely used as a media center or home theater system (HTPC). Using software like Kodi or OSMC, Raspberry Pi can stream movies, music, and TV shows, making it a cost-effective alternative to traditional media players.
• Example: With RetroPie, Raspberry Pi can also be used as a retro gaming console, capable of running games from classic systems like NES, SNES, and Sega Genesis.

4. Robotics Projects

• Use Case: Raspberry Pi is a favorite among hobbyists and researchers for building robots. It provides the necessary computing power and connectivity to control motors, sensors, and other components in robotics projects.
• Example: Raspberry Pi can be used to create an autonomous robot that uses sensors like ultrasonic for navigation and cameras for object recognition. It can be programmed to follow specific behaviors, respond to environmental stimuli, and even perform complex tasks.

5. Server Projects (Personal Cloud, Web Server, VPN)

• Use Case: Raspberry Pi can act as a web server, file server, or even a VPN server. Its low cost and energy efficiency make it an excellent choice for hosting small-scale services.
• Example: Raspberry Pi can host a Nextcloud server, allowing users to store and access files remotely. It can also host a private website or provide web development environments for testing.
• Example: Raspberry Pi is frequently used as a VPN server, enabling secure remote access to private networks and internet browsing.

6. Network Attached Storage (NAS)

• Use Case: Raspberry Pi can be configured as a NAS device that provides networked storage for local networks. By connecting external drives to the Pi, users can create a simple yet powerful file server for home use.
• Example: Raspberry Pi can serve as a home backup solution, providing centralized storage and file sharing for multiple users or devices.

7. Security and Surveillance Systems

• Use Case: Raspberry Pi is frequently used for building security cameras and surveillance systems. With cameras and motion detection sensors, Raspberry Pi can be integrated into a home or office security system.
• Example: MotionEyeOS is a popular software that turns Raspberry Pi into a motion-detection camera system. It can send alerts, stream video, and save footage for later review.

8. Scientific Research and Data Logging

• Use Case: Raspberry Pi is used in scientific research to monitor and log data from sensors. It can handle temperature sensors, humidity sensors, and various environmental monitoring devices, making it ideal for lab experiments.
• Example: Raspberry Pi can be used to log environmental data, such as temperature and humidity, in a greenhouse and then upload it to a cloud service for analysis.

How Raspberry Pi Works Along with Architecture?

The Raspberry Pi’s architecture is built around several core components that provide the power, connectivity, and flexibility required for various applications. Here’s a look at how it works:

1. Central Processing Unit (CPU)

• The Broadcom ARM-based CPU is the heart of the Raspberry Pi. It performs the computations and manages tasks. The CPU typically operates at clock speeds ranging from 1 GHz to 1.5 GHz, depending on the model.
• Raspberry Pi’s architecture allows it to run lightweight operating systems like Raspberry Pi OS, making it suitable for a wide range of tasks from basic computing to embedded systems.

2. Graphics Processing Unit (GPU)

• The Broadcom VideoCore IV GPU handles all graphical tasks, such as video playback, rendering images, and supporting 3D graphics for multimedia applications. This allows the Raspberry Pi to support HD video and even gaming via emulation.
• The GPU is integrated into the same chip as the CPU, enabling efficient performance in multimedia tasks.

3. Memory (RAM)

• Raspberry Pi models come with RAM ranging from 256 MB to 8 GB, depending on the model. This memory is used for the operating system and active programs. The more RAM a model has, the more complex and memory-intensive tasks it can handle.
• The shared memory model between the CPU and GPU means that both use the same memory resources, optimizing system performance for multimedia and processing.

4. General Purpose Input/Output (GPIO) Pins

• Raspberry Pi includes GPIO pins, which are used for connecting sensors, switches, motors, LEDs, and other electronics. The GPIO pins allow Raspberry Pi to interact with the physical world and are used in countless projects like robotics, home automation, and IoT systems.

5. Storage (SD Card Slot)

• Raspberry Pi uses a microSD card for both storage and booting. The operating system, programs, and data are stored on this card, which can be easily swapped or upgraded to increase storage capacity or upgrade the system.
• The Pi also supports external USB storage for additional data needs, providing users with flexible storage options.

6. Connectivity

• Most Raspberry Pi models come with Ethernet or Wi-Fi connectivity, enabling it to connect to the internet or a local network.
• Bluetooth support is also available in newer models like the Raspberry Pi 3 and Raspberry Pi 4, making it ideal for wireless communication with peripherals.

7. Power Supply

• Raspberry Pi requires a 5V power supply, typically via micro-USB or USB-C (depending on the model). Power is a critical aspect of the Raspberry Pi’s architecture, as it ensures the board and peripherals can function properly without drawing too much energy.

What Are the Basic Workflow of Raspberry Pi?

Raspberry Pi’s workflow revolves around setting up the hardware, installing the operating system, and using the device for specific projects or tasks. Here’s how the basic workflow unfolds:

Step 1: Setup Hardware

• Connect peripherals such as a keyboard, mouse, monitor, and SD card with the operating system. You can also set it up without peripherals using headless SSH (for remote control).

Step 2: Install the Operating System

• Download and install the Raspberry Pi OS or another compatible OS onto a microSD card using the official Raspberry Pi Imager or Etcher software. Insert the SD card into the Raspberry Pi and power it on.

Step 3: Initial Configuration

• Upon first boot, configure system settings such as language, time zone, and Wi-Fi settings. You may also want to enable SSH for remote access.

Step 4: Install Additional Software

• Use the apt-get package manager to install software packages as needed. Install programming tools, libraries, or even software like Apache, Python, or RetroPie.

Step 5: Build Your Project

• Once the Raspberry Pi is set up, you can begin working on your project. Whether it’s home automation, robotics, or a media server, use the appropriate hardware and software configurations.

Step-by-Step Getting Started Guide for Raspberry Pi

Step 1: Choose a Raspberry Pi Model

• Select the model that suits your needs. The Raspberry Pi 4 is great for most projects, while the Raspberry Pi Zero is ideal for small, low-power projects.

Step 2: Install Raspberry Pi OS

• Download Raspberry Pi OS and flash it onto a microSD card. Use tools like Raspberry Pi Imager or Etcher for installation.

Step 3: Set Up Peripherals

• Attach a keyboard, mouse, and monitor to your Raspberry Pi. If you are setting up headless, enable SSH and connect to the Pi over Wi-Fi or Ethernet.

Step 4: Power Up

• Connect the power supply, insert the microSD card, and power on the Raspberry Pi.

Step 5: Configure System

• Complete the initial setup, set up Wi-Fi, and change settings like locale and timezone.

Step 6: Install Additional Software

• Use the Terminal to install packages such as Python, Node.js, or other tools to meet your project needs.

Step 7: Start Building Projects

• Use GPIO pins for electronics, run programs, and experiment with different setups depending on your project (e.g., IoT, robotics, media center).

The post The Ultimate Guide to Getting Started with Raspberry Pi: From Setup to Projects appeared first on scmGalaxy.

What is a Makefile?

A Makefile is a special file used by the make utility to automate the process of building and managing dependencies in software projects. It is a text file that contains a set of rules and instructions for compiling, linking, and organizing the execution of tasks in a project. Makefiles are essential for managing complex software projects, especially those with many source files and dependencies.

The make tool reads the instructions in the Makefile and executes the necessary commands to compile or process files in the correct order. Makefiles are most commonly used in C and C++ development environments, but they are applicable to any programming language and can be used to automate tasks such as testing, deployment, or file organization.

A Makefile consists of rules, which include:

• Targets: The file or outcome to be created (e.g., executable file or object files).
• Dependencies: Files that are required to create the target.
• Commands: Instructions that must be executed to build the target from the dependencies.

Basic Syntax of a Makefile:

target: dependencies
    command

Each rule specifies a target, the dependencies required for the target, and the command(s) to execute. The commands are usually preceded by a tab character.

What are the Major Use Cases of Makefile?

Makefiles are primarily used to automate repetitive tasks in software development. Here are some major use cases:

1. Build Automation

Makefiles are widely used to automate the process of compiling and linking source files into executable programs. By defining a set of rules, developers can ensure that the build process is consistent, efficient, and reproducible. This is especially useful when working with large projects with multiple source files and dependencies.

Example:
A project may contain many .c files that need to be compiled into .o files before linking them into an executable. A Makefile can automate this process and recompile only the files that have changed since the last build.

2. Managing Dependencies

One of the key features of Makefiles is their ability to track dependencies between files. If a file changes, make will automatically recompile any targets that depend on it. This ensures that only the necessary parts of the project are rebuilt, saving time and computational resources.

Example:
In a project with a library and several applications depending on it, when the library is updated, make will only recompile the applications that depend on it, rather than rebuilding the entire project.

3. Task Automation Beyond Building

While Makefiles are primarily used for compiling code, they can also be used to automate other tasks in a development pipeline, such as:

• Running tests after a build.
• Deploying a project to a production server.
• Cleaning up temporary files (e.g., .o, .log files).
• Generating documentation or performing lint checks.

Example:
A Makefile can automate running unit tests after building the software, ensuring that the project is always properly tested after each modification.

4. Cross-Platform Compatibility

Makefiles can be used to create projects that can be built on different platforms. By abstracting platform-specific commands into variables, developers can create Makefiles that work across different operating systems and environments.

Example:
A Makefile could use conditional checks to determine whether it’s running on Linux, Windows, or macOS, and adjust the build commands accordingly.

5. Continuous Integration (CI)

Makefiles are often used in CI/CD (Continuous Integration/Continuous Deployment) pipelines to automate builds and tests. CI systems like Jenkins or Travis CI can use Makefiles to automate the process of building software, running tests, and deploying the results.

Example:
A CI pipeline might automatically execute make commands to compile code, run unit tests, and deploy the application whenever new code is pushed to a version control system (e.g., GitHub).

How Makefile Works Along with Architecture?

The make utility reads the Makefile, processes the rules, and determines which targets need to be updated based on the dependencies. It does this by comparing the timestamps of the target files and their dependencies. If a dependency has changed (i.e., its timestamp is newer than the target file), make will execute the associated commands to rebuild the target.

1. Target and Dependency Resolution

• A target is the file that is generated by the build process, such as an executable, object file, or other output.
• A dependency is a file required by the target. If any dependency is updated (modified), the target must be rebuilt.
• If a target has multiple dependencies, make will check if any dependency has changed and will only rebuild the target if necessary.

2. Rule Processing

• A Makefile contains multiple rules, each defining a target, its dependencies, and the commands required to generate the target.
• The commands in the Makefile are executed in the order of the dependencies. For example, if an object file (file.o) is a dependency of an executable (file), make will first check whether file.o is up-to-date before attempting to link file.o to create the final executable.

3. Handling Multiple Rules

• A Makefile can contain multiple rules for different targets. make will follow the dependency chain for each target, ensuring that all prerequisites are built before the target itself.

Example:
The following Makefile builds an executable program from two object files main.o and helper.o:

program: main.o helper.o
    gcc -o program main.o helper.o

main.o: main.c
    gcc -c main.c

helper.o: helper.c
    gcc -c helper.c

4. Phony Targets

Some targets in a Makefile, like clean, do not correspond to actual files but are used to represent tasks (e.g., cleaning up temporary files). These targets are called phony targets, and they are always executed when requested.

Example:

.PHONY: clean
clean:
    rm -f *.o program

5. Variables

Makefiles support variables that allow for reuse of common values across the file. These variables can simplify complex Makefiles, improve maintainability, and make it easier to modify the build configuration.

Example:

CC = gcc
CFLAGS = -Wall -g

program: main.o helper.o
    $(CC) $(CFLAGS) -o program main.o helper.o

Basic Workflow of Makefile

The basic workflow of using a Makefile consists of the following steps:

1. Define Targets:
   Specify the targets that need to be created, such as executables or intermediate object files.
2. Specify Dependencies:
   List the dependencies of each target. If any dependency changes, the target will be rebuilt.
3. Write Commands:
   Provide the commands to be executed in order to build the target from the dependencies. These commands are executed only if the target is out-of-date.
4. Run make:
   Run the make utility on the command line, passing the desired target as an argument. For example, running make program will attempt to build the program target.

Step-by-Step Getting Started Guide for Makefile

Here is a step-by-step guide to creating and using a Makefile for a simple C program:

Step 1: Create Your Project Files

Assume you have a C program with the following structure:

• main.c: The main source file.
• helper.c: A helper source file.
• helper.h: Header file for helper.c.

Step 2: Create the Makefile

In your project directory, create a file named Makefile (no extension). Then, write the following contents:

CC = gcc
CFLAGS = -Wall -g

program: main.o helper.o
    $(CC) $(CFLAGS) -o program main.o helper.o

main.o: main.c
    $(CC) $(CFLAGS) -c main.c

helper.o: helper.c helper.h
    $(CC) $(CFLAGS) -c helper.c

clean:
    rm -f *.o program

Step 3: Understand the Makefile

• Variables: CC and CFLAGS are variables that specify the compiler and the compiler flags, respectively.
• Targets: The targets are program, main.o, helper.o, and clean.
• Dependencies: For example, main.o depends on main.c, and helper.o depends on helper.c and helper.h.
• Commands: The commands after each target are executed when the target needs to be rebuilt.

Step 4: Run make

Open a terminal in the project directory and type the following command to build the program target:

make program

The make utility will check if any of the dependencies are outdated and execute the appropriate commands to create the program.

Step 5: Clean the Project

To remove the compiled object files and executable, use the clean target:

make clean

Step 6: Modify and Test

Modify the source files (e.g., change main.c or helper.c) and re-run make program. Only the necessary files will be recompiled.

The post Understanding Makefiles: Use Cases, Architecture, and Getting Started Guide appeared first on scmGalaxy.

What is Ubuntu?

Ubuntu is a popular open-source Linux-based operating system developed and maintained by Canonical Ltd. It is designed to be user-friendly, secure, and versatile for both desktop and server environments. Ubuntu is based on Debian Linux and follows a regular release cycle, with Long-Term Support (LTS) versions supported for up to 5 years.

Ubuntu provides a complete operating system environment, including a graphical user interface (GUI), command-line tools, development libraries, and software repositories. It supports a wide range of hardware platforms and comes preloaded with essential applications and utilities.

Known for its stability and ease of use, Ubuntu is widely adopted by individuals, businesses, educational institutions, and cloud providers.

What Are the Major Use Cases of Ubuntu?

Ubuntu’s flexibility and robustness make it suitable for a variety of use cases:

1. Desktop Operating System

• Ideal for everyday users, developers, and professionals.
• Supports a wide range of software for office productivity, multimedia, programming, and gaming.

2. Server Operating System

• Powers web servers, database servers, mail servers, and file servers.
• Popular in enterprise and cloud environments due to stability and security.

3. Cloud and Virtualization

• Widely used in cloud computing platforms like AWS, Azure, Google Cloud, and OpenStack.
• Supports containerization technologies such as Docker and Kubernetes.

4. Development Platform

• Provides rich development tools and supports programming languages including Python, Java, C++, and more.
• Preferred for open-source software development and testing.

5. Education and Research

• Used in academic institutions for teaching operating systems, programming, and system administration.

6. IoT and Embedded Systems

• Lightweight Ubuntu Core variant used in Internet of Things devices.

How Ubuntu Works Along with Architecture

Ubuntu inherits its architecture from Linux and Debian, consisting of several layers working together to provide a full operating system:

Key Architectural Components:

1. Linux Kernel
   • The core of Ubuntu, managing hardware, system resources, and providing essential services like process management, memory management, device drivers, and file systems.
2. System Libraries
   • Libraries such as GNU C Library (glibc) provide APIs for system calls and basic functions.
3. System Daemons and Services
   • Background processes handling tasks like networking (NetworkManager), printing (CUPS), and logging (rsyslog).
4. Init System (systemd)
   • Responsible for bootstrapping the system and managing services during runtime.
5. User Interface
   • Ubuntu Desktop uses graphical environments like GNOME or KDE.
   • Ubuntu Server primarily uses command-line interfaces but can run GUIs if needed.
6. Package Management
   • Uses Advanced Packaging Tool (APT) and DEB packages to manage software installation, updates, and dependencies.
7. User Applications
   • Desktop software, development tools, utilities, and server applications installed as packages.

What Are the Basic Workflows of Ubuntu?

The workflow when using Ubuntu typically includes:

1. Installation
   • Download Ubuntu ISO and create bootable media.
   • Install Ubuntu via guided setup.
2. System Configuration
   • Set up user accounts, network, software sources, and system settings.
3. Package Management
   • Use APT to install, update, and remove software packages.
4. System Updates
   • Regularly update the OS and installed packages for security and feature improvements.
5. User Interaction
   • Use GUI or CLI for daily tasks such as file management, running applications, and system monitoring.
6. System Administration
   • Manage services, users, permissions, and backups.
7. Development and Deployment
   • Write and run software, deploy web and application servers.

Step-by-Step Getting Started Guide for Ubuntu

Step 1: Download Ubuntu

• Visit the official site: ubuntu.com/download
• Choose Desktop or Server version based on your needs.

Step 2: Create Bootable Installation Media

• Use tools like Rufus (Windows) or Etcher (cross-platform) to create a bootable USB drive.

Step 3: Install Ubuntu

• Boot from USB and follow installation prompts:
  • Select language, keyboard layout.
  • Choose installation type (dual boot or clean install).
  • Partition disk if needed.
  • Create user account.

Step 4: Post-Installation Setup

• Update system packages: sudo apt update && sudo apt upgrade
• Install essential software using: sudo apt install <package_name>

Step 5: Explore the Desktop or Server

• For Desktop, familiarize yourself with GNOME interface, software center, terminal.
• For Server, learn basic CLI commands, SSH setup, and service management.

Step 6: Configure Networking and Security

• Set up firewall using ufw (Uncomplicated Firewall): sudo ufw enable sudo ufw allow ssh
• Configure network interfaces if required.

Step 7: Customize and Extend

• Install additional drivers, themes, or development tools.
• Explore snap packages for easy app installation: sudo snap install <app_name>

Step 8: Backup and Maintenance

• Set up automated backups.
• Regularly update the system.

The post Exploring Ubuntu: Overview, Use Cases, Architecture, and Getting Started appeared first on scmGalaxy.

Prometheus is an open-source system monitoring and alerting toolkit originally built at SoundCloud. Many companies and organizations have adopted Prometheus and have a very active developer and user community in the project. It is now a standalone open-source project and is maintained independently of any company.

Features of Prometheus:

• A multi-dimensional data model with time series data identified by metric name and key/value pairs.
• PromQL, a flexible query language to leverage this dimensionality.
• No reliance on distributed storage; single server nodes are autonomous.
• Time series collection happens via a pull model over HTTP.

What is Grafana?

Grafana is an open-source solution for running data analytics, understanding large amounts of data and monitoring our apps with the help of cool customizable dashboards.

What are the benefits of Grafana?

• Customizable dashboards are feature-rich and can be configured to display data from a wide range of databases using visualization tools such as heatmaps, histograms, and charts.
• The platform is flexible and easy to use.
• Native support of a broad range of databases.

Grafana Features:

• Dashboard templating – This is a Grafana feature that is really useful. It allows users to create a dashboard setup to suit their every need.
• Provisioning – It can be simple enough to set up a single dashboard with a few clicks, dragging and dropping, but some users need even more ingenuity this way.
• Annotations – This Grafana feature lets you mark graphs, which is especially helpful when you need to correlate data in case something misbehaves.
• Custom plugins – You can extend the functionality of Grafana with plugins that provide additional tools, visualizations, and more.
• Teams and permissions – Where an organization has an instance of Grafana and multiple teams, they usually prefer to have the option of implementing some dashboard isolation.

Pre-requisites to learn Prometheus and Grafana:

• Basic experience with Linux/Unix system administration.
• Familiarity with common shell commands, such as ls, cd, curl, etc.
• Some knowledge and/or development experience in Go and Python.
• Some experience working with Kubernetes.

If you are planning to learn Prometheus and Grafana, go with DevOpsSchool institute. Will provide you online and classroom training and certification course Program by an expert. To get in-depth knowledge of Prometheus and Grafana along with its various applications, check out our interactive, live-online training.

Here you can see the Agenda of Prometheus and Grafana Course:

This course covers the basics of Prometheus and Grafana and their main features. You will develop a critical understanding of why Prometheus and Grafana are useful and how they can be combined with other web development frameworks.

You will learn about the basics of Prometheus and Grafana and their advantages. Then, you’ll cover more advanced topics like integrating Prometheus and Grafana with other frameworks.

Hopefully, I think this information is helpful for you.

However, if you want to find out more details, be sure to check out our Prometheus and Grafana course to learn more about this technology.

The post What is Prometheus & grafana and best course and certification in India? appeared first on scmGalaxy.

Given that the LAMP stack is based on Linux and that the entire open-source community is working to enhance it, it is also deemed secure. All security updates and patches are accessible as an automatic unattended install on an Ubuntu VPS as soon as they are released in the Ubuntu repos, so make sure you configure your system to automatically install them if you are concerned about security.If you don’t enable this option on your server and don’t manually install the latest upgrades and patches, you’re placing your server at risk of being hacked.

Install the unattended-upgrades package to enable automatic unattended upgrades.

sudo apt-get install unattended-upgrades

Edit the /etc/apt/apt.conf.d/50unattended-upgrades file to specify which package categories should be upgraded automatically.

2. Configure firewall

Another very important aspect of overall security is having a properly set firewall. ufw is Ubuntu’s default firewall configuration tool, and it’s turned off by default. You can use the following commands to enable ufw:

sudo ufw enable

Allow essential services like OpenSSH and Apache to be accessed:

sudo ufw allow 22
sudo ufw allow 80
sudo ufw allow 443

It’s simple to grant access to other services. Simply change the port number in the samples above to the port number of the service you wish to enable access to, and you’re done. Even if the machine is rebooted, the firewall rules will remain active.

3. Disable unused services

If you have active services which you are not using, you can simply disable them. For example, if you have service like Dovecot up and running on your server and you are not using it at all, stop and disable the service using the following commands:

sudo systemctl stop dovecot.service
sudo systemctl disable dovecot.service

4. Install Fail2ban

Fail2ban is a service that scans log files for excessive login failures and blocks the IP address that is displaying malicious behaviour. If you don’t use two-factor or public/private authentication techniques on services like OpenSSH, this service comes in handy. Run the following command to install Fail2ban:

sudo apt-get install fail2ban

Make a copy of the default configuration file so you can make modifications without worrying about system updates overwriting them:

sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local

Edit the jail.local file:

sudo nano /etc/fail2ban/jail.local

The [sshd] block should look something like this:

[sshd]

enabled  = true
port     = ssh
filter   = sshd
logpath  = /var/log/auth.log
maxretry = 5
bantime = 600

To make the modifications take effect, save the file and restart Fail2ban:

sudo systemctl restart fail2ban.service

Enable Fail2ban on system boot:

sudo systemctl enable fail2ban.service

5. Hide Apache sensitive information

The default Apache setup exposes a great deal of sensitive data that can be used against the service. It’s critical to keep this information secret, therefore make a configuration file for your new settings:

sudo nano /etc/apache2/conf-available/custom.conf

Copy and paste the following text:

ServerTokens Prod
ServerSignature Off
TraceEnable Off
Options all -Indexes
Header unset ETag
Header always unset X-Powered-By
FileETag None

If it isn’t already enabled, enable the Apache headers module:

sudo a2enmod headers

Enable the following settings:

sudo a2enconf custom.conf

To make the modifications take effect, restart Apache:

sudo systemctl restart apache2.service

6. Install and enable mod_security

Mod security is a web application firewall (WAF) that may be added to Apache as a separate module. It can be used to protect a web server from a variety of threats, including SQL injections, session hijacking, cross-site scripting, and malicious user agents. Run the instructions following to install and enable mod security:

sudo apt-get install libapache2-modsecurity2
sudo a2enmod security2

You should setup the module and enable the OWASP ModSecurity Core Rule Set after it has been installed (CRS).

sudo mv /etc/modsecurity/modsecurity.conf-recommended /etc/modsecurity/modsecurity.conf

Then, open the /etc/modsecurity/modsecurity.conf file and edit/add the following settings:

SecRuleEngine On
SecResponseBodyAccess Off
SecRequestBodyLimit 8388608
SecRequestBodyNoFilesLimit 131072
SecRequestBodyInMemoryLimit 262144

Save and close the file. Remove the current CRS and download the OWASP CRS by using the following commands:

sudo rm -rf /usr/share/modsecurity-crs
sudo git clone https://github.com/SpiderLabs/owasp-modsecurity-crs.git /usr/share/modsecurity-crs
cd /usr/share/modsecurity-crs
sudo mv crs-setup.conf.example crs-setup.conf

Edit the security2.conf file in /etc/apache2/mods-enabled/security2.conf. It should resemble the following:

<IfModule security2_module>
	SecDataDir /var/cache/modsecurity
	IncludeOptional /etc/modsecurity/*.conf
	IncludeOptional "/usr/share/modsecurity-crs/*.conf"
	IncludeOptional "/usr/share/modsecurity-crs/rules/*.conf
</IfModule>

Finally, to make the modifications take effect, restart Apache:

sudo systemctl restart apache2.service

7. Install and enable mod_evasive

Mod evasive is an Apache module that can prevent DoS (Denial of Service), DDoS (Distributed Denial of Service), and brute-force assaults on the web server. Run the following command to install mod evasive on your server:

sudo apt-get install libapache2-mod-evasive

Open the default configuration file /etc/apache2/mods-enabled/evasive.conf and edit the settings to look like those below:

<IfModule mod_evasive20.c>
	DOSPageCount        5
	DOSSiteCount        50
	DOSPageInterval     1
	DOSSiteInterval     1
	DOSBlockingPeriod   600
	DOSLogDir           "/var/log/mod_evasive"
</IfModule>

The file should be saved and closed. Make a folder for the log files:

sudo mkdir /var/log/mod_evasive
sudo chown -R www-data: /var/log/mod_evasive

Restart Apache:

sudo systemctl restart apache2.service

The post How to Secure Your Apache Server appeared first on scmGalaxy.

• Since the beginning of the course, all the examples presented were run
• using a user account.
• A user account consists of a username and a password. This identifies the
• user on the system and, hence, maintains security and accountability.
• Linux also creates groupsfor each user account. A group may contain one or
• more users, all of them sharing the same permissions.
• The system administrator account, sometimes called the superuser, is the
• root. This is the most important account on the system. It must be owned by
• as a few users as possible because of the vast powers it provides.

The /etc/passwd file

• This is one of the most important and highly protected system file. It contains various information about the user accounts on the system.
• Each user account information is contained on a single line. A colon (:) is used to separate different fields from each other. Let’s have a quick look at each one in turn:
  • Username: the string that the user uses for identification. It is a friendly name that is chosen by the system administrator (root) to identify the user. By convention, it is all lowercase characters, it may contain numbers (but cannot start with one), special characters dash (-), udnerscore (_), and – in some distros – the dollar sign ($) at the end.
  • Password: a secret group of characters that should be known only to it’s owner. The /etc/passwd file places an x in this field, indicating that the encrypted password is stored in /etc/shadow file (more on that later).

UID and GID

• UID: it is short for user id. This is a unique number that identifies the user account on the system. As a matter of fact, Linux security system does not care about the username of the user account; it works by examining the its UID to provide the appropriate permissions and access rights. Since there are user accounts that are reserved for system accounts, those are assigned UID numbers from 0 (which is the root account) up till 500 (they reach 1000 in some systems). The higher numbers are assigned to normal (non-system) user accounts.
• GID: short for group id, it is the unique number that identifies a group account. A group contain one or more users that share similar access rights. The main purpose of the existence of groups is to provide certain users with access to specific files and directories while preventing others. Think of a directory on which a team of users are working. Putting those users in a group ensures that all of them will have the same permissions.

The comment and the home directory

• The comment field normally includes the user’s real name. For example, when a username is jdoe, the real name in the comment could be John Doe. It may also contain other personal information like the phone number, address and others.
• The home directory field contains the path to the user’s home directory. Only the user is the owner of his/her home directory. At the command line, a home directory can be referred to as tilde ~. For example, cd ~ will make you navigate to your home directory.

The default shell

• We have mentioned before that bash is not the only shell available for Linux. There are other shells that are available for Linux like ksh, zsh, tsh and so on. The shell field contains the path to the binary file of the specific shell. For example, /bin/bash.
• The default shell is a matter of choice. A user can change hi/her default shell.
• Since all users (including system accounts) must have a default shell. But system accounts – by nature – do not (and should not) have login access to the system. Accordingly, the default shell of such accounts is set to /sbin/nologin. Setting the default shell to /bin/nologin prints a friendly message explaining that logins with this account are not available. Setting it to /bin/false denies login without displaying that message.

The /etc/shadow file

• You might think that a file named /etc/passwd should be the one containing the hashed passwords of the users on the system.
• Actually this was the case long ago. But for security reasons, and since /etc/passwd file must be readiable by all users on the system to be able to authenticate them, the hashed password was removed from that file and placed in a more secured file: /etc/shadow .This file has higher level of protection and access restrictions.
• It contains the following information:
  • The salt: this is a random input that helps make the password more protected
  • The hash: the result of an irreversible mathematical operation. It is performed on the password and the salt combined. To authenticate a user, a hash is computed for the entered password, with the salt input added to it. If both hashes are identical the user is authenticated.
  • Password history: these are some variables that help increase user security. For example, the password must be changed after a specific number of days (configured by the system administrator).

/etc/shadow fields

• The username: this is the username of the user and not the UID. It is what links /etc/passwd with /etc/shadow
• The password: the salted hash of the user password. If this field contains as asterisk or an exclamation mark, this means that the account is locked.
• Last password change: this is the date of the last password change. The UNIX timestamp is used here. UNIX timestamp is a date/time measurement method. It is the amount of time that passed since POSIX time (1/1/1970 at midnight). This field contains the number of days that passed since POSIX time.
• The number of days till a password can be changed. This is another security measure that prevents users from changing their passwords (as per policy) and then quickly setting it back to the original one.
• The number of days before a user must change the current password. This is sometimes referred to as password age.
• The number of warning days before a password expires. During those days, a warning message will be displayed to the users whose account will expire soon.
• Days between expiration and deactivation: if configured, the account can be deactivated after it’s expired. The difference is that when the account expires, the password is not erased and the account can be activated again by the system administrator or by the user logging in and changing the password. But if the account is deactivated, the password is deleted and only the system administrator can reactivate the account.
• Expiration date: the date when the account expires, expressed as the number of days since POSIX time.
• Special flag: this field is currently not used. It is reserved for future use.
• Notice that some day fields may contain either -1 or 9999, which effectively means that the relevant feature is disabled

The post Linux security appeared first on scmGalaxy.

1. ip – from Iproute2, a collection of utilities for controlling TCP/IP networking and traffic control in Linux.
2. ls – list directory contents.
3. df – display disk space usage.
4. du – estimate file space usage.
5. free – display memory usage.
6. scp – securely Copy Files Using SCP, with examples.
7. find – locates files based on some user-specified criteria.
8. ncdu – a disk utility for Unix systems.
9. pstree – display a tree of processes.
10. last – show a listing of last logged-in users.
11. w – show a list of currently logged-in user sessions.
12. grep – Search a file for a pattern of characters, then display all matching lines. 13. uptime – shows system uptime and load average.
14. top – shows an overall system view.
15. vmstat – shows system memory, processes, interrupts, paging, block I/O, and CPU info.
16. htop – interactive process viewer and manager.
17. dstat – view processes, memory, paging, I/O, CPU, etc., in real-time. All-in-one for vmstat, iostat, netstat, and ifstat.
18. iftop – network traffic viewer.
19. nethogs – network traffic analyzer.
20. iotop – interactive I/O viewer. Get an overview of storage r/w activity.
21. iostat – for storage I/O statistics.
22. netstat – for network statistics.
23. ss – utility to investigate sockets.
24. atop – For Linux server performance analysis.
25. Glances and nmon – htop and top Alternatives:
26. ssh – secure command-line access to remote Linux systems.
27. sudo – execute commands with administrative privilege.
28. cd – directory navigation.
29. pwd – shows your current directory location.
30. cp – copying files and folders.
31. mv – moving files and folders.
32. rm – removing files and folders.
33. mkdir – create or make new directories.
34. touch – used to update the access date and/or modification date of a computer file or directory.
35. man – for reading system reference manuals.
36. apropos – Search man page names and descriptions. 37. rsync – remote file transfers and syncing.
38. tar – an archiving utility.
39. gzip – file compression and decompression.
40. b2zip – similar to gzip. It uses a different compression algorithm.
41. zip – for packaging and compressing (to archive) files.
42. locate – search files in Linux.
43. ps – information about the currently running processes.
44. Making use of Bash scripts. Example: ./bashscript.sh
45. cron – set up scheduled tasks to run.
46. nmcli – network management.
47. ping – send ICMP ECHO_REQUEST to network hosts.
48. traceroute – check the route packets take to a specified host.
49. mtr – network diagnostic tool.
50. nslookup – query Internet name servers (NS) interactively.
51. host – perform DNS lookups in Linux.

The post Top 51 Linux commands for daily use appeared first on scmGalaxy.

Step 1 – Download & Install Grafana
Download Grafana RPM file RPM for Linux from https://grafana.com/grafana/download?platform=linux

# RHEL 7

$ sudo yum install initscripts fontconfig -y
$ wget https://s3-us-west-2.amazonaws.com/grafana-releases/release/grafana-5.2.2-1.x86_64.rpm
$ sudo yum localinstall grafana-5.2.2-1.x86_64.rpm

Step 2 – Understand Grafana Installation details in RHEL/CENTOS

1. Installs binary to /usr/sbin/grafana-server
2. Copies init.d script to /etc/init.d/grafana-server
3. Installs default file (environment vars) to /etc/sysconfig/grafana-server
4. Copies configuration file to /etc/grafana/grafana.ini
5. Installs systemd service (if systemd is available) name grafana-server.service
6. The default configuration uses a log file at /var/log/grafana/grafana.log
7. The default configuration specifies an sqlite3 database at /var/lib/grafana/grafana.db

Step 3 – Start the server (init.d service)

$ sudo service grafana-server start

This will start the grafana-server process as the grafana user, which is created during package installation. The default HTTP port is 3000, and default user and group is admin.

Step 4 – Configure the Grafana server to start at boot time

$ sudo /sbin/chkconfig --add grafana-server
$ sudo systemctl enable grafana-server.service
$ systemctl daemon-reload
$ systemctl start grafana-server
$ systemctl status grafana-server

Step 5 – Grafana server Environment file
The systemd service file and init.d script both use the file located at /etc/sysconfig/grafana-server for environment variables used when starting the back-end. Here you can override log directory, data directory and other variables.

Step 6 – Grafana server Log
By default Grafana will log to /var/log/grafana

Step 7 – Grafana Database
The default configuration specifies a sqlite3 database located at /var/lib/grafana/grafana.db. Please backup this database before upgrades.

You can also use MySQL or Postgres as the Grafana database, as detailed on
http://docs.grafana.org/installation/configuration/#database

Step 8 – Grafana configuration
The configuration file is located at /etc/grafana/grafana.ini. Go the Configuration page for details on all those options. You can add following data sources

1. Graphite
2. InfluxDB
3. OpenTSDB
4. Prometheus

Step 9 – Server side image rendering
Server side image (png) rendering is a feature that is optional but very useful when sharing visualizations, for example in alert notifications.

$ sudo yum install fontconfig -y
$ sudo yum install freetype* -y
$ sudo yum install urw-fonts -y

Step 10 – Browse the dashboard
http://X.X.X.X.:3000/
Username – admin
Password – admin

The post Install and Configure Grafana in RHEL 7 appeared first on scmGalaxy.

What is SELinux and how its SELinux used in Docker?

There are three popular solutions for implementing access control in Linux:

1. SELinux
2. AppArmor
3. GrSecurity

Security-Enhanced Linux (SELinux) is a Linux kernel security module that provides a mechanism for supporting access control security policies. It is a security feature of the Linux kernel. It is designed to protect the server against misconfigurations and/or compromised daemons. It put limits and instructs server daemons or programs what files they can access and what actions they can take by defining a security policy.

SELinux is an implementation of a MAC security mechanism. MAC is an acronym for Mandatory Access Control (MAC). It is built into the Linux kernel and enabled by default on Fedora, CentOS, RHEL and a few other Linux distributions. SELinux allows server admin to define various permissions for all process. It defines how all processes can interact with other parts of the server such as:

• Pipes
• Files
• Network ports
• Sockets
• Directories
• Other process

SELinux puts restrictions on each of the above object according to a policy. For example, an apache user with full permission can only access /var/www/html directory, but can not touch other parts of the system such as /etc directory without policy modification. If an attacker managed to gain access to sendmail mail or bind dns or apache web server, would only have access to exploited server and the files normally has access as defined in the policy for the server. An attacker can not access the other parts of the system or internal LAN. In other words, damage can be now restricted to the particular server and files. The cracker will not able to get a shell on your server via common daemons such as Apache / BIND / Sendmail as SELinux offers the following security features:

• Protect users’ data from unauthorized access.
• Protect other daemons or programs from unauthorized access.
• Protect network ports / sockets / files from unauthorized access.
• Protect server against exploits.
• Avoid privilege escalation and much more.

Please note that SELinux is not a silver bullet for protecting the server. You must follow other security practices such as

• Implementing firewalls policy.
• Server monitoring.
• Patching the system on time.
• Writing and securing cgi/php/python/perl scripts.

The /etc/selinux/config configuration file controls whether SELinux is enabled or disabled, and if enabled, whether SELinux operates in permissive mode or enforc-ing mode.

SETTING OF SELINUX
SELinux is set in three modes.

Enforcing – SELinux security policy is enforced. IF this is set SELinux is enabled and will try to enforce the SELinux policies strictly

Permissive – SELinux prints warnings instead of enforcing. This setting will just give warning when any SELinux policy setting is breached

Disabled – No SELinux policy is loaded. This will totally disable SELinux policies.

SELinux policies
SELinux allows for multiple policies to be installed on the system, but only one policy may be active at any given time. At present, two kinds of SELinux policy exist:

Targeted – The targeted policy is designed as a policy where most processes operate without restrictions, and only specific ser-vices are placed into distinct security domains that are confined by the policy.

Strict – The strict policy is designed as a policy where all processes are partitioned
into fine-grained security domains and confined by policy.

To put SELinux into enforcing mode:

$ sudo setenforce 1

To query the SELinux status:

$ getenforce

To see SELinux status in simplified way you can use sestatus

$ sestatus

To get elobrated info on difference status of SELinux on different services use -b option along sestatus

$ sestatus -b

How to disable SElinux?

We can do it in two ways
1)Permanent way : edit /etc/selinux/config
change the status of SELINUX from enforcing to disabled
SELINUX=enforcing
to
SELINUX=disabled
Save the file and exit.

2)Temporary way : Execute below command
echo 0 > /selinux/enforce
or
setenforce 0

How about enabling SELinux?

1)Permanent way : edit /etc/selinux/config
change the status of SELINUX from disabled to enforcing
SELINUX=disabled
to
SELINUX=enforcing
Save the file and exit.

2)Temporary way : Execute below command
echo 1 > /selinux/enforce
or
setenforce 1

Now lets understand Docker with SELinux?
The interaction between SELinux policy and Docker is focused on two concerns: protection of the host, and protection of containers from one another.

SELinux labels consist of 4 parts:

User:Role:Type:level.

SELinux controls access to processes by Type and Level. Docker offers two forms of SELinux protection: type enforcement and multi-category security (MCS) separation.

Docker has the –selinux-enabled flag by default in CentOS 7.4.1708. However, in case your image or your configuration management tool is disabling it, as was the case for our puppet module verify this, you verify by running the following comman

$ docker info | grep 'Security Options'

[root@ip-172-31-80-30 ec2-user]# more /etc/selinux/config

# This file controls the state of SELinux on the system.
# SELINUX= can take one of these three values:
# enforcing - SELinux security policy is enforced.
# permissive - SELinux prints warnings instead of enforcing.
# disabled - No SELinux policy is loaded.
SELINUX=enforcing
# SELINUXTYPE= can take one of three two values:
# targeted - Targeted processes are protected,
# minimum - Modification of targeted policy. Only selected processes are pro
tected.
# mls - Multi Level Security protection.
SELINUXTYPE=targeted

Refernece
https://www.cyberciti.biz/faq/what-is-selinux/
https://en.wikipedia.org/wiki/Security-Enhanced_Linux
http://jaormx.github.io/2018/selinux-and-docker-notes/

The post What is SELinux and how its SELinux used in Docker? appeared first on scmGalaxy.

sudo mount -n -o remount,rw /

The post Configuring NFS to access the files from remote Linux machine as a mount point appeared first on scmGalaxy.

The post Linux User Management appeared first on scmGalaxy.

check “disable_ipv6″ file to check if IPv6 is disabled,enter:
[root@devops ~]# cat /proc/sys/net/ipv6/conf/all/disable_ipv6
0
if you get “0” value, it means that IPv6 is enabled and “1” means it is disabled.

How to Disable IPv6 in linux system?
vim /etc/sysctl.conf

Adding the below lines into that file:

net.ipv6.conf.all.disable_ipv6 = 1
net.ipv6.conf.default.disable_ipv6 = 1
net.ipv6.conf.lo.disable_ipv6 = 1

Save and close that file, then restart sysctl with the following command:

[root@devops ~]# sysctl -p

Now you can rerun the “ifconfig” command to check if IPv6 lines have been removed.

To Enabled IPv4

Edit “/etc/sysconfig/network-scripts/ifcfg-eth0″ file, which is your defualt first NIC configuration file.

If you are using DHCP server to take IP then, edit it like this;

#vi /etc/sysconfig/network-scripts/ifcfg-eth0

ONBOOT=”yes”
BOOTPROTO=”dhcp”

Save & restart networking service,

#service network restart OR
#/etc/init.d/network restart
Regards,
Rajesh Kumar
Twitt me @ twitter.com/RajeshKumarIn

The post Disable IPv6 and Enable IPv4 in Red Hat Linux appeared first on scmGalaxy.

1. How to send an email | check email | reply email attachment using command line??
2. How do you connect to the internet in linux?
4. How can i restrict a aceess of the file? (Add user, add group)

The post Answer some of Linux admin questions… appeared first on scmGalaxy.

Starting sonar..../sonar.sh: line 490: /usr/local/sonar-2.2/bin/linux-x86-64/./wrapper: cannot execute binary file

The post Starting sonar issues in linux appeared first on scmGalaxy.

Hi,

Can you tell me How to access windows share folder from linux?

Reagrs,
scm

scmuser replied the topic: Re:How to access windows share folder from linux

I found solution 1:

Press Alt+f2 and put following shared link such as smb://10.4.40.88/Share in the text box and Run…

scmuser replied the topic: Re:How to access windows share folder from linux

To test whether Samba is installed or not…

type following command…
testparm /etc/samba/smb.conf

Testparm will parse your configuration file and report any unknown parameters or incorrect syntax. It also performs a check for common misconfigurations and will issue a warning if one is found.

chidamla replied the topic: Re:How to access windows share folder from linux
Samba is one method.

Another method is to execute an ftp service in any Windows server and configure the Windows share drive as the home folder in the ftp service. Connect Linux server to the ftp service to transfer files. This set-up is worth it when there needs to be frequent transfer of files.

For one time transfers use, winscp tools.

The post How to access windows share folder from linux appeared first on scmGalaxy.

How can we list our all the users in Linux?

How to list all the users created in linuz machine?

rajeshkumar replied the topic: Re: List all the Grups and users in linux

Following command will work for you….

less /etc/passwd
less /etc/group

Regards,
Rajesh Kumar
Twitt me @ twitter.com/RajeshKumarIn

The post List all the Grups and users in linux appeared first on scmGalaxy.

As you see the if statement can nested, similarly loop statement can be nested. You can nest the for loop. To understand the nesting of for loop see the following shell script.
$ vi nestedfor.sh
for (( i = 1; i <= 5; i++ )) ### Outer for loop ### do for (( j = 1 ; j <= 5; j++ )) ### Inner for loop ### do echo -n "$i " done echo "" #### print the new line ### done Run the above script as follows: $ chmod +x nestedfor.sh $ ./nestefor.sh 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 4 4 4 4 4 5 5 5 5 5 Here, for each value of i the inner loop is cycled through 5 times, with the varible j taking values from 1 to 5. The inner for loop terminates when the value of j exceeds 5, and the outer loop terminets when the value of i exceeds 5. Following script is quite intresting, it prints the chess board on screen. $ vi chessboard for (( i = 1; i <= 9; i++ )) ### Outer for loop ### do for (( j = 1 ; j <= 9; j++ )) ### Inner for loop ### do tot=`expr $i + $j` tmp=`expr $tot % 2` if [ $tmp -eq 0 ]; then echo -e -n "\033[47m " else echo -e -n "\033[40m " fi done echo -e -n "\033[40m" #### set back background colour to black echo "" #### print the new line ### done Run the above script as follows: $ chmod +x chessboard $ ./chessboard Above shell script cab be explained as follows:

The post Nested for loop in Linux Shell Script appeared first on scmGalaxy.

cat /etc/passwd | cut -d”:” -f1
Regards,
Rajesh Kumar
Twitt me @ twitter.com/RajeshKumarIn

rajeshkumar replied the topic: Re: List all the users in linux
Some of other options are….

cat /etc/passwd | gawk ‘FS=”:” {print $1}’

ls /home

cat /etc/passwd | cut -d: -f 1,3,6 | grep “[5-9][0-9][0-9]” | grep “/home” | cut -d: -f1
Regards,
Rajesh Kumar
Twitt me @ twitter.com/RajeshKumarIn

The post List all the users in linux appeared first on scmGalaxy.

Problem Statement: In one windows machine, I have one application (BusinessObject) file which has to perform some kind of import jobs upon getting parameters on command line.

The command to execute this import statement in windows is:
java -jar biarengine.jar <>

As part of automation in my project, I am trying to run this command along with parameter from Linux machine. I mean to say when I fire these command from Linux machine, it should get executed in Windows machine.

My questions is: What are the way we have available on which I can fire these command and make sure these got executed in Windows remotely.
Any help on this?

kd09714 replied the topic: Re: Execute Command from Linux to Windows machine
using rsh you can trigger the command on windows box.

rsh WIN-BOX-NAME “command to execute on cmd prompt”;

The post Execute Command from Linux to Windows machine appeared first on scmGalaxy.