Forem: Zahraa Jawad

Hosting n8n on AWS EC2 with Docker

Zahraa Jawad — Sun, 06 Jul 2025 16:03:58 +0000

Outline
Introduction to n8n
Why use n8n
Steps to build and run n8n on AWS

Introduction to n8n
It’s open-source, offering a free self-hosted option and affordable cloud plans. It blends no-code simplicity with low-code flexibility, supporting everything from basic automation to custom-coded integrations. This versatility fuels a wide range of n8n use cases, making it a go-to for anyone aiming to automate smarter.

Why use n8n

n8n (pronounced n-eight-n) helps you to connect any app with an API with any other, and manipulate its data with little or no code.
Customizable: Highly flexible workflows and the option to build custom nodes.
Convenient: Use npm or Docker to try out n8n, or the Cloud hosting option if you want us to handle the infrastructure.
Privacy-focused: Self-host n8n for privacy and security.
from n8n documintation

Steps to build and run n8n on AWS
In this article, we will use AWS to build n8n in simple steps by creating a free tier instance in our AWS account and installing Docker and Docker Compose to build and run n8n.

Before we start, note that this setup is unencrypted (HTTP only) and is suitable for testing or development environments only.

Step 1: "Launch Instance"

When logging into the AWS account, we select the EC2 service through Services or by the search box:

Click on Launch instance

Under Name and tags

Enter a name to identify your instance. For this tutorial, name the instance (n8n-server)

Under Application and OS Images:

From Quick Start, choose an AMI that meets your web server needs
Here we choose Ubuntu (which is free tier eligible)

Under Instance type:

Choose the type of instance. Here we choose t2.micro(which is a free tier eligible).

Under Key pair (login):

Choose the key pair

or create a new key pair:
Give a name to the key pair, then click Create key pair

Under Network settings: under Firewall (security groups)

Choose to create security groups
To Allow SSH traffic by clicking on the check box

Leave all other configurations as they are (default settings)

In the Summary panel, review your instance configuration and then choose Launch instance.

Successfully initiated the launch of the instance, and to see the instance, click on the ID:

Your instance will first be Pending, and will then go into the Running state.

Step 2: "Connect to the instance"

To connect to your instance, select the instance and choose Connect.

There are many ways to connect to EC2, here we will choose the SSH client to connect.
After selecting the "SSH Client" section, copy and execute the following commands in the terminal as per the following steps:

Open Terminal (here we use Git Bash)

Change the directory with the cd command (change directory), where you have downloaded your pem file(key pair).

In this article, the pem file is stored in the downloads folder.

Execute the cd command to change the path to the location of the encryption key
cd Download/

Execute the following commands sequentially

chmod 400 [key pair name].pem
ssh -i /path/key-pair-name.pem instance-user-name@instance-public-dns-name

After the command is executed you will be prompted to type “Yes” to continue with the connection

And that’s it! Now we’re logged in to our AWS instance.

Now, to complete our work, we get root permission by executing the sudo -i command:

Executing the command "sudo -i" means booting as root on Linux. This command's main feature is that it gives you full admin (root user) privileges, allowing you to perform commands and operations that require root user privileges.
We update the repositories through the command:
sudo apt update && sudo apt upgrade -y

Step 3: "Install Docker"

After connecting to the instance via SSH and obtaining the root privilege, use the following command automation to install Docker:
sudo apt update sudo apt install -y docker.io sudo systemctl enable docker sudo systemctl start docker

Docker has been installed on the instance successfully.

Docker experience: Run a simple test command docker -v to check that Docker is working properly and to see the Docker version:

Step 4:Install Docker Compose:
Now we install Docker Compose using the command:
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" \ -o /usr/local/bin/docker-compose

Grant operating permissions:
sudo chmod +x /usr/local/bin/docker-compose

Then, check the installation by running the command:
docker-compose --version

Step 5: Install n8n
First, we create a project folder for n8n and prepare the necessary files.

Create a folder for our project using the mkdircommand, and enter this folder using the cdcommand, as: mkdir ~/n8n-server && cd ~/n8n-server mkdir n8n_data

Then permit the data folder: sudo chown -R 1000:1000 ./n8n_data

Create the docker-compose.yml file

Now we create the docker-compose.yml file, through the command vim or nano and put the code in the file. Here we will use the command nano:
nano docker-compose.yml

And past the codes:

Note: N8N_HOST=[Puplic Ip of your instance]
and N8N_WEBHOOK_URL=http://[Puplic Ip of your instance]:5678/

Then exit the file from the keyboard by ctrl x, then y (to save the file) then click Enter

Step 6: Open the n8n port in AWS:

To open the port for the host n8n, go to your AWS account and select the instance that was created for the server, then select security and open your security group:

Choose the inboud rules then Edit inbound rules

Click on Add rule

Enter the rule:

We choose the type: Custom TCP, port: 5678, and source: 0.0.0.0/0 (or choose a private IP address for more security).
Note: In practice, it is not preferable to leave the state 0.0.0.0/0 This is easy to hack, but we are here to learn the labs and the building process.

Run the n8n:
To run the n8n, we execute the command:
docker-compose up -d

To verify that the container is running, we execute the command:
docker ps

The container has been launched successfully, and now we can go to the browser to run the application.

Now, go back to the instance and select it, then go to the Details and copy the Public IPv4 address

Paste the public IPv4 address with port 5678 into the browser and press Enter

n8n has been successfully built.This is the first account setup page (owner account).

We enter our email, first name, last name, and a strong password, then click Next.

We will complete the rest of the settings according to your work.

n8n is now fully operational on a public IP of AWS EC2 using Docker and is ready to build your Workflows or connect with your other tools.

References:

AI-Powered Text Analysis Using AWS Comprehend with a Flask Web Interface

Zahraa Jawad — Tue, 05 Nov 2024 19:44:34 +0000

Introduction to the idea of the work

In this work, we will build a Text Analysis application using AWS AI services. This application will allow users to enter text, and then process it using Amazon Comprehend to extract Sentiment Analysis, Entity Recognition, and Categories.

Amazon Comprehend

Here’s what Amazon says about Amazon Comprehend in their official documentation:

Amazon Comprehend uses natural language processing (NLP) to extract insights about the content of documents. It develops insights by recognizing the entities, key phrases, language, sentiments, and other common elements in a document. Use Amazon Comprehend to create new products based on understanding the structure of documents. For example, using Amazon Comprehend you can search social networking feeds for mentions of products or scan an entire document repository for key phrases.You can access Amazon Comprehend document analysis capabilities using the Amazon Comprehend console or using the Amazon Comprehend APIs. You can run real-time analysis for small workloads or you can start asynchronous analysis jobs for large document sets. You can use the pre-trained models that Amazon Comprehend provides, or you can train your own custom models for classification and entity recognition.Amazon Comprehend uses a pre-trained model to examine and analyze a document or set of documents to gather insights about it. This model is continuously trained on a large body of text so that there is no need for you to provide training data.

(Quoted from Amazon Comprehend in their official documentation)

Key benefits of our work:

Easily analyze text data: This application enables us to quickly analyze texts to extract sentiment (positive, negative, mixed), entities (such as names and places), and important keywords.
Using AWS cloud services: You can explore and use AWS AI services such as Amazon Comprehend to provide advanced analytics in a simple and effective way.
Displaying results in an understandable and organized way: The results are displayed in the form of understandable and clear tables in a black interface (such as an SSH screen) and a web page. This enhances the understanding of the analytics.
Interactive web interface: The web interface allows you to view the analysis results in an organized and easy-to-understand way, making it easy to share or display the results to others.
Learning and using Flask: It provides an opportunity to learn how to create a simple web application using Flask, which adds skill in developing web applications with Python.

The steps we need will be as follows:

Launch an instance (your machine)
Setting up a Python virtual environment
Configure AWS Credentials
Write Python code to display results

Step (1)-Launch an instance (your machine)
You can find the same steps of the launch and connect of instance described in the article:
https://dev.to/zahraajawad/building-a-jupyter-notebook-environment-in-docker-for-data-analysis-on-aws-ec2-376i

Note: Make sure you choose the security group:
- Port 5000: This is the default port that Flask uses to serve the web application.

- Port 22: required for SSH access to your instance, which you use via Git to connect to the server.

After updating the system through the command
sudo apt update && sudo apt upgrade –y we install Python by the command :
sudo apt install python3 python3-venv python3-pip –y

Step (2)- Setting up a Python virtual environment
A virtual work environment can be created by creating a new folder for work and then creating the virtual environment within this folder. This is done through the following steps and commands:

- Create a project folder by the command mkdir my_project

- Then change the current directory by the command cd my_project

-Now we create our virtual environment with the command python3 -m venv venv

-We activate the virtual environment through source venv/bin/activate

Successfully built and activated

- Now we need to make sure that boto3, Flask, and pandas are installed in our virtual environment and this is done through the command:
pip install boto3 pandas Flask

Step (3)- Configure AWS Credentials
We now configure AWS Credentials to ensure that Amazon Comprehend can access resources securely and authoritatively. This is a way to verify the identity of a user or application and grant it the necessary permission to use the services and resources required to operate, This is done through:

We install awscli in the Python virtual environment through the command: pip install awscli

Then we make sure that the installation was successful by the command:
aws --version

After installation, we configure the credentials using the command:
aws configure
Where we will need to enter our account credentials on the AWS:

Access Key.
Then the Secret Access Key.
And the Default region name - such as us-west-2 or ap-south-1.
Finally the Default output format - which can be left blank or set to json

Step (4)-Write Python code to display results

We will create two codes to display the results of text analysis using the service Amazon Comprehend:

By displaying on the black screen (the terminal).
By displaying on the web page by creating a simple web application using Flask.

Displaying text analysis results on the black screen(the terminal
)
We create a new file called text_analysis.py which contains the following functions and codes which we will explain in detail and which we will use to implement the text analysis and display on the black screen:

To import the necessary libraries, boto3 and pandas, we use:

import boto3
import pandas as pd

To create an AWS Comprehend client using the boto3 library we use:


comprehend = boto3.client('comprehend')

text - The written text will be used for sentiment analysis, entity extraction, and key phrase detection:

text = "AWS is a great service provider for AI applications."

For Sentiment Analysis, we use:

- comprehend.detect_sentiment: Calls AWS Comprehend to perform analysis on the text.

- LanguageCode='en': Specifies the language of the text (here is English)

- sentiment_response: Stores the AWS Comprehend response, which includes sentiment details and scores.

- sentiment_data: Contains the scores for each sentiment (positive, negative, neutral, mixed).

sentiment_response = comprehend.detect_sentiment(Text=text, LanguageCode='en')
sentiment_data = sentiment_response['SentimentScore']

To display the sentiment analysis results:

The sentiment scores are converted to a DataFrame using pandas to display them in an organized manner without index numbers.

and to_string(index=False): Used to display the data without index numbers.

print("\nSentiment Analysis Results:")
sentiment_df = pd.DataFrame([sentiment_data], columns=['Positive', 'Negative', 'Neutral', 'Mixed'])
print(sentiment_df.to_string(index=False))

To extract entities: comprehend.detect_entities calls the AWS Comprehend service to extract entities in the text. As for entities_data: It contains a list of the extracted entities (such as names, organizations, etc.), their type, and their accuracy levels.

entities_response = comprehend.detect_entities(Text=text, LanguageCode='en')
entities_data = entities_response['Entities']

To create and display data for entities, a DataFrame is created from the extracted data and displayed in a structured form.

entities_df = pd.DataFrame(entities_data)[['Text', 'Type', 'Score']]
print("\nEntities Recognition Results:")
print(entities_df.to_string(index=False))

To discover key phrases, the following is used:

comprehend.detect_key_phrases: Calls the AWS Comprehend service to discover key phrases in the text.
key_phrases_data: Contains a list of key phrases and their accuracy scores.

key_phrases_response = comprehend.detect_key_phrases(Text=text, LanguageCode='en')
key_phrases_data = key_phrases_response['KeyPhrases']

The DataFrame here is created from the main phrases and displayed in an organized form.

key_phrases_df = pd.DataFrame(key_phrases_data)[['Text', 'Score']]
print("\nKey Phrases Detection Results:")
print(key_phrases_df.to_string(index=False))

So the entire text_analysis.py file is:

import boto3
import pandas as pd

# Create AWS Comprehend Client
comprehend = boto3.client('comprehend')

# Text to be analyzed
text = "AWS is a great service provider for AI applications."

# Sentiment Analysis
sentiment_response = comprehend.detect_sentiment(Text=text, LanguageCode='en')
sentiment_data = sentiment_response['SentimentScore']

# Show sentiment analysis results
print("\nSentiment Analysis Results:")
sentiment_df = pd.DataFrame([sentiment_data], columns=['Positive', 'Negative', 'Neutral', 'Mixed'])
print(sentiment_df.to_string(index=False))

# Entity extraction
entities_response = comprehend.detect_entities(Text=text, LanguageCode='en')
entities_data = entities_response['Entities']

# Create a DataFrame for entities
entities_df = pd.DataFrame(entities_data)[['Text', 'Type', 'Score']]
print("\nEntities Recognition Results:")
print(entities_df.to_string(index=False))

# Extract keywords
key_phrases_response = comprehend.detect_key_phrases(Text=text, LanguageCode='en')
key_phrases_data = key_phrases_response['KeyPhrases']

# Create a DataFrame for Keywords
key_phrases_df = pd.DataFrame(key_phrases_data)[['Text', 'Score']]
print("\nKey Phrases Detection Results:")
print(key_phrases_df.to_string(index=False))

Now through the command vim or nano create the text_analysis.py file and put the above code in the file, here we will use the command nano:
nano text_analysis.py

And past the codes:

then exit the file from the keyboard by ctrl x then y (to save the file) then click enter

Now we run the code and check the results by executing the following command:
python3 text_analysis.py

The results will appear as formatted tables on the black screen:

Displaying the results on the web page by creating a simple web application using the Flask library in Python

To display the results on the web page by creating a simple web application using Flask, we create a new file called app.py which contains the following functions and codes which we will explain in detail and which we will use to implement the text analysis and display on the Web page:

Below is to import the libraries needed to work

from flask import Flask, render_template_string
import boto3
import pandas as pd

To initialize and create a new Flask application object, we use:

app = Flask(__name__)

The code below is to create the home page path:

@app.route('/')
def home():

To create an AWS Comprehend client:

comprehend = boto3.client('comprehend')

The text that will be parsed by AWS Comprehend (here our text is "AWS is a great service provider for AI applications.")

 text = "AWS is a great service provider for AI applications."

To analyze sentiment, we use: detect_sentiment: which calls the AWS Comprehend service to analyze the sentiment in the text. sentiment_response: stores the AWS service response. Then convert the results to a DataFrame to display them in an organized manner

sentiment_response = comprehend.detect_sentiment(Text=text, LanguageCode='en')
    sentiment_data = sentiment_response['SentimentScore']
    sentiment_df = pd.DataFrame([sentiment_data], columns=['Positive', 'Negative', 'Neutral', 'Mixed'])

detect_entities function: Calls the AWS Comprehend service to extract entities from text, then converts the results to a DataFrame

entities_response = comprehend.detect_entities(Text=text, LanguageCode='en')
    entities_data = entities_response['Entities']
    entities_df = pd.DataFrame(entities_data)[['Text', 'Type', 'Score']]

To discover key phrases, the detect_key_phrases function is used, which calls the AWS service to discover key phrases and then converts the results to a DataFram

key_phrases_response = comprehend.detect_key_phrases(Text=text, LanguageCode='en')
    key_phrases_data = key_phrases_response['KeyPhrases']
    key_phrases_df = pd.DataFrame(key_phrases_data)[['Text', 'Score']]

HTML template is used to display results where as templates are used to display tables in a web page.

html_template = """
    <h2>Sentiment Analysis Results:</h2>
    {{ sentiment_table | safe }}
    <h2>Entities Recognition Results:</h2>
    {{ entities_table | safe }}
    <h2>Key Phrases Detection Results:</h2>
    {{ key_phrases_table | safe }}

The to_html(index=False) function converts tables from DataFrames to HTML without index numbers

sentiment_table = sentiment_df.to_html(index=False)
    entities_table = entities_df.to_html(index=False)
    key_phrases_table = key_phrases_df.to_html(index=False)

To render HTML and display tables on the page, the render_template_string function is used

return render_template_string(html_template, sentiment_table=sentiment_table,
                                  entities_table=entities_table, key_phrases_table=key_phrases_table)

Finally, to run the Flask application, we need to use: app.run(): To run the Flask application. host='0.0.0.0': Makes the application available on all IP addresses of the host. port=5000: specifies the port to run the application (here port 5000). debug=True: Runs the application in debug mode to provide error information.

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=True)

So the entire app.py file is:

from flask import Flask, render_template_string
import boto3
import pandas as pd

app = Flask(__name__)

@app.route('/')
def home():
# Create AWS Comprehend Client
    comprehend = boto3.client('comprehend')

# Text to be analyzed
    text = "AWS is a great service provider for AI applications."

# Sentiment Analysis
    sentiment_response = comprehend.detect_sentiment(Text=text, LanguageCode='en')
    sentiment_data = sentiment_response['SentimentScore']
    sentiment_df = pd.DataFrame([sentiment_data], columns=['Positive', 'Negative', 'Neutral', 'Mixed'])

# Entity extraction
    entities_response = comprehend.detect_entities(Text=text, LanguageCode='en')
    entities_data = entities_response['Entities']
    entities_df = pd.DataFrame(entities_data)[['Text', 'Type', 'Score']]

# Extract keywords
    key_phrases_response = comprehend.detect_key_phrases(Text=text, LanguageCode='en')
    key_phrases_data = key_phrases_response['KeyPhrases']
    key_phrases_df = pd.DataFrame(key_phrases_data)[['Text', 'Score']]

# HTML templates to display results
    html_template = """
    <h2>Sentiment Analysis Results:</h2>
    {{ sentiment_table | safe }}
    <h2>Entities Recognition Results:</h2>
    {{ entities_table | safe }}
    <h2>Key Phrases Detection Results:</h2>
    {{ key_phrases_table | safe }}
    """

# Convert DataFrame to HTML
    sentiment_table = sentiment_df.to_html(index=False)
    entities_table = entities_df.to_html(index=False)
    key_phrases_table = key_phrases_df.to_html(index=False)

    return render_template_string(html_template, sentiment_table=sentiment_table,
                                  entities_table=entities_table, key_phrases_table=key_phrases_table)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=True)

Now in the same way to create app.py file using vim or nano command and put the above code in the file, here we will also use nano command:

nano app.py

then past the codes:

then exit the file from the keyboard by ctrl x then y (to save the file) then click enter

The last step is to run the Flask application, which is done with the command:

python3 app.py

When you run app.py, the terminal should display a URL as shown below:

Now to view the results, we open the browser on our device and enter the URL link through the following steps:

Go back to the instance and select it by the checkbox.
Go to the Details and copy the Public IPv4 address.

Then paste the public IPv4 address with port 5000 into the browser and press Enter.

The webpage is working successfully and all the results (sentiment analysis, extracted entities, key phrases) can be seen on the webpage where they are organized through our use of the Flask library.

References:

Building a Go Application with Docker on AWS: Creating a RESTful Interface for Adding and Retrieving Items

Zahraa Jawad — Sun, 27 Oct 2024 18:58:03 +0000

Introduction

While most Go applications are compiled into a single binary file, web applications also come with templates, assets, and configuration files; these can get out of sync and cause erroneous deployments.
Docker allows us to create a standalone image with everything our application needs to run. In this article, we will learn how to deploy a Go web application using Docker installed on an instance, and how Docker can help you improve your development workflow and deployment process.

The steps we need will be as follows:

- Launch an instance (your machine)to build Docker on and the Go application
- Install Docker in instance
- Installing Go in instance
- Create code files for your Go application
- Application Testing

Launch an instance (your machine)to build Docker on and the Go
application

You can find the same steps of the launch and connect of instance described in the article:

https://dev.to/zahraajawad/building-a-jupyter-notebook-environment-in-docker-for-data-analysis-on-aws-ec2-376i

Note: Make sure you choose the security group:

SSH-Port 22: To access and connect to the instance using SSH
protocol to manage the system remotely.
HTTP-Port 8080: To run the Go application on this port (8080) to access it from the Internet or local network, this port must be open.

- Install Docker in our instance

The specific workflow architecture we will create uses Docker to provide an integrated workflow environment.
So after connecting to the instance via SSH and obtaining the root privilege, use the following command automation to install Docker:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add - && sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" && sudo apt-get update && apt-cache policy docker-ce

Docker experience: Run a simple test command docker -v to check that Docker is working properly and to see the Docker version:

Installing Go

You can install Go by downloading it from the official Go website https://go.dev/dl/
wget https://golang.org/dl/go1.20.linux-amd64.tar.gz sudo tar -C /usr/local -xzf go1.20.linux-amd64.tar.gz echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bash_profile source ~/.bash_profile

where :
wget https://golang.org/dl/go1.20.linux-amd64.tar.gz is to download Go binary.

and
sudo tar -C /usr/local -xzf go1.20.linux-amd64.tar.gz is to extract the tarball to /usr/local.
and
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bash_profile to Update the PATH environment variable.
and source ~/.bash_profile to apply the changes made to the profile

So after executing the commands and verifying the execution through the command ls to show the downloaded files:

Initialize the Go application with the following code:
go mod init my-go-app

Now we need to create a project folder by the command:
mkdir <name of our work>
Then change the current directory by the command :
cd <name of our work>
so the execution is :

Create code files for your Go application

The main.go file

We create a new file called main.go which contains the following functions and codes which we will explain in detail and then we put all the codes in the main.go file:

To import the necessary packages we use the code:

import (
    "encoding/json"
    "log"
    "net/http"
    "github.com/gorilla/mux"
    "os"
)

For the data structure item:

type Item struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

where itemis a data structure containing an identifier (ID) and a name (Name). These fields are converted to JSON format using tags (json:"id" and json:"name".

items variable

var items []Item

which is a slice of items stored in server memory.

Through the main function the structures are arranged by reading the port (here it will be on port 8080) in addition to directing the various requests from retrieving or adding a new element and displaying a simple HTML page.

func main() {
    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }

    router := mux.NewRouter()
    router.HandleFunc("/items", getItems).Methods("GET")
    router.HandleFunc("/items", createItem).Methods("POST")
    router.HandleFunc("/", serveHome).Methods("GET")

    log.Printf("Server is running on port %s...\n", port)
    log.Fatal(http.ListenAndServe(":"+port, router))
}

The function getItems returns a list of items in JSON format. The content type in the header is set to application/json.

func getItems(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(items)
}

The createItem function adds a new item to the items list. The data is read from the Request Body in JSON format, the item is assigned an ID based on the number of existing items, and the added item is returned as JSON.

func createItem(w http.ResponseWriter, r *http.Request) {
    var item Item
    json.NewDecoder(r.Body).Decode(&item)
    item.ID = len(items) + 1
    items = append(items, item)
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(item)
}

The serveHome function displays a simple HTML page with a welcome message (Welcome to the Go App) and links to access the data.

func serveHome(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "text/html")
    w.WriteHeader(http.StatusOK)
    w.Write([]byte(`
        <!DOCTYPE html>
        <html lang="en">
        <head>
            <meta charset="UTF-8">
            <meta name="viewport" content="width=device-width, initial-scale=1.0">
            <title>Go App</title>
        </head>
        <body>
            <h1>Welcome to the Go App</h1>
            <p>This is a simple API application.</p>
            <p>Access <a href="/items">/items</a> to see all items.</p>
        </body>
        </html>
    `))
}

So the entire main.go file is:

package main

import (
    "encoding/json"
    "log"
    "net/http"
    "github.com/gorilla/mux"
    "os"
)

// Item represents the data structure we will be using
type Item struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

var items []Item

func main() {
    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }

    router := mux.NewRouter()
    router.HandleFunc("/items", getItems).Methods("GET")
    router.HandleFunc("/items", createItem).Methods("POST")
    router.HandleFunc("/", serveHome).Methods("GET")

    log.Printf("Server is running on port %s...\n", port)
    log.Fatal(http.ListenAndServe(":"+port, router))
}

func getItems(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(items)
}

func createItem(w http.ResponseWriter, r *http.Request) {
    var item Item
    json.NewDecoder(r.Body).Decode(&item)
    item.ID = len(items) + 1
    items = append(items, item)
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(item)
}

func serveHome(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "text/html")
    w.WriteHeader(http.StatusOK)
    w.Write([]byte(`
        <!DOCTYPE html>
        <html lang="en">
        <head>
            <meta charset="UTF-8">
            <meta name="viewport" content="width=device-width, initial-scale=1.0">
            <title>Go App</title>
        </head>
        <body>
            <h1>Welcome to the Go App</h1>
            <p>This is a simple API application.</p>
            <p>Access <a href="/items">/items</a> to see all items.</p>
        </body>
        </html>
    `))
}

Now through the command vim or nano create the main.go file and put above code in the file, here we will use the command nano:

nano main.go

And past the codes:

then exit the file from the keyboard by ctrl x then y (to save the file) then click enter

Dockerfile:

Is a text document that contains all the commands a user could call on the command line to assemble an image.
Dockerfile can build images automatically by reading the instructions from a Dockerfile.

Create a Dockerfile:

A Dockerfile with build instructions is required to build a container image with Docker.
We create a Dockerfile and add the following code in the same way as before through the command nano Dockerfile:

Dockerfile command details can be found on the docker docs homepage https://docs.docker.com/guides/golang/build-images/

Now that we have prepared the Dockerfile, it is time to build a Docker image for the Go application. The image can be made from the official Docker images which are:

docker build -t my-go-app .

The image is successfully built, and to make sure of the build by using the command:
docker images

Then to run the container after building the image, we use:

docker run -p 8080:8080 my-go-app

where 8080 is the port of the web servers, so the execution run is:

Application Testing

- Test the Go application by the curl command

To test whether the Go application works properly through the curl command by:

curl http://localhost:8080/items

curl http://<public IPv4 address of our instance>:8080/items

the execution is null, which means the application is working but we have no data yet.

To add an item, by the command:

curl -X POST -H "Content-Type: application/json" -d '{"name": "item"}' http://localhost:8080/items

curl -X POST -H "Content-Type: application/json" -d '{"name": "item"}' http://<public IPv4 address of our instance>:8080/items

so the execution of adding:

we can add another item:

- Test the Go application by the web page

To test whether the Go application works properly through the web page, the following steps:

Go back to the instance and select it by the checkbox.
Go to the Details and copy the Public IPv4 address.
Paste the public IPv4 address with port 8080 into the browser and press Enter.

The web page is working and when we press on items on the page we obtain the items that add by the curl command.

Or can press the checkbox of Pretty-print:

References:

Building a Jupyter Notebook Environment in Docker for Data Analysis on AWS EC2

Zahraa Jawad — Mon, 30 Sep 2024 20:37:36 +0000

Outline

What is Jupyter Notebook
Docker in the AWS environment with the Jupyter Notebook
Install Jupyter Notebook using Docker in an AWS environment

What is Jupyter Notebook

JupyterLab: A Next-Generation Notebook Interface JupyterLab is the latest web-based interactive development environment for notebooks, code, and data. Its flexible interface allows users to configure and arrange workflows in data science, scientific computing, computational journalism, and machine learning. A modular design invites extensions to expand and enrich functionality.

JupyterLab is the latest web-based interactive development environment for notebooks, code, and data. Its flexible interface allows users to configure and arrange workflows in data science, scientific computing, computational journalism, and machine learning. A modular design invites extensions to expand and enrich functionality.

Docker in the AWS environment with the Jupyter Notebook
In this work, we will take practical and distinctive advantage of the uses of Docker installed in the AWS environment by building and preparing an environment for data analysis using Jupyter Notebook inside a Docker container and running it on AWS EC2, as it provides many important benefits, especially in the fields of data analysis and data science. These benefits include:

1. Portability and Replication
Docker containers ensure that your work environment is consistent across different systems. You can easily move the container between different machines without worrying about system compatibility.

2. Ease of Setup and Operation
With AWS EC2, you can quickly set up a new instance and launch a Docker container. This reduces the time and effort required to set up a data analysis environment, allowing you to focus on the actual work instead of setting up the infrastructure.

3. Easily Scalable
AWS EC2 provides the flexibility to scale resources as needed. You can increase or decrease the size of the instance based on your analysis requirements, saving operational costs and ensuring optimal performance.

4. Remote Access and Collaboration
Jupyter Notebook provides an interactive web interface that can be accessed from anywhere. This facilitates collaboration between teams, as multiple users can access the same environment and work on the same projects in real-time.

5. Integration with Big Data Tools
You can integrate Jupyter Notebook with big data tools like Apache Spark and Hadoop, making it easier to analyze and visualize big data.

Data Security With AWS, you can use advanced security features like Identity and Access Management (IAM), Virtual Private Networks (VPC), and encryption, ensuring your sensitive data is protected.

Install Jupyter Notebook using Docker in an AWS environment

To install Jupyter Notebook using Docker in an AWS environment, follow these steps:

Step 1 "Launch Instance"

When logging into the AWS account, we select the EC2 service through Services or by the search box:

Click on Launch instance

Under Name and tags:

Enter a name to identify your instance, For this tutorial, name the instance (Jupyter Notebook)

Under Application and OS Images:

From Quick Start, choose an AMI that meets your web server needs
Here we choose Ubuntu (which is free tier eligible)

Under Instance type:

Choose the type of instance, here we choose t2.micro(which is a free tier eligible).

Under Key pair (login):

Choose the key pair

or create new key pair:
Give a name to the key pair, then click Create key pair:

Under Network settings: under Firewall (security groups)

Choose to Create security groups
To Allow SSH traffic by clicking on the check box

Leave all other configurations as they are (default settings)

In the Summary panel, review your instance configuration and then choose Launch instance.

Successfully initiated launch of instance and to see the instance click on the ID:

Your instance will first be Pending, and will then go into the Running state.

Step 2: "Connect to the instance"

To connect to your instance, select the instance and choose Connect.

There are many ways to connect to ec2, here we will choose the SSH client to connect.
After selecting the "SSH Client" section, copy and execute the following commands in the terminal as per the following steps:

Open Terminal (here we use Git Bash)

Change the directory with the cd command (change directory), where you have downloaded your pem file(key pair).

In this article, the pem file is stored in the downloads folder.

Execute the cd command to change the path to the location of the encryption key
cd Download/

Execute the following commands sequentially

1-Chmod 400 [key pair name].pem

2-ssh -i /path/key-pair-name.pem instance-user-name@instance-public-dns-name

After the command is executed you will be prompted to type “Yes” to continue with the connection

And that’s it! Now we’re logged in to our AWS instance.

Now We get root permission by executing the sudo -i command

Executing the command "sudo -i" means booting as root on Linux. The main feature of this command is that it gives you full admin (root user) privileges, allowing you to perform commands and operations that require root user privileges.

We update the repositories through the command:
sudo apt update && sudo apt upgrade -y

Docker installation:
I used Docker installed on an instance in the AWS account, and this was explained in the article:

https://dev.to/zahraajawad/docker-basics-with-some-of-its-commands-and-how-to-install-docker-by-aws-7b6

• Create a Dockerfile

Create a Dockerfile describing how to build the image. This file contains the instructions necessary to install and configure the application within the image.
we can do it by the command(nano):
nano Dockerfile

Write the instructions necessary to install and configure the application:

Then follow the steps to store and exit the file:
Ctrl+x : to exit
Y: to save then enter.

Now to build the Jupyter Notebook image we execute the following command:

docker build -t my-jupyter-notebook .

Image built successfully

To make sure, we execute the command:
docker images

run the container using the following command:
docker run -d -p 8888:8888 my-jupyter-notebook

Access to Jupyter Notebook
To access Jupyter Notebook, we must open its port, and this is done through the following steps:

Go back to the instance and select it by clicking on the checkbox, then go to the security box

Open the security group by clicking on it

Choose the Inbound rules then edit Inbound rules

Click Add Rule

Enter the rule Note: In practice, it is not preferable to leave the state 0.0.0.0/0 This is easy to hack, but we are here to learn the labs and the building process.

Now, Go back to the instance and select it, then go to the Details and copy the Public IPv4 address

Paste the public IPv4 address with port 8888 into the browser and press Enter

Jupyter Notebook has been successfully built and you can work on it

References:

Setting Up a Secure Wazuh Environment by AWS EC2

Zahraa Jawad — Sun, 16 Jun 2024 21:52:01 +0000

Introduction:

Wazuh is an open-source security platform that aims to help organizations monitor and manage security incidents, detect threats, and ensure compliance with security regulations. It provides capabilities for intrusion detection, log analysis, vulnerability detection, and threat intelligence, wazuh is trusted and used by thousands of organizations around the world. With its powerful features and flexible capabilities, it has become a preferred choice for those looking for a reliable and flexible open-source security platform. Wazuh is a powerful security platform that combines threat detection and response capabilities and is characterized by the ability to integrate and customize to meet the needs of different organizations.

Features of Wazuh

Protect endpoints and cloud workloads: Wazuh provides continuous protection for on-ground and cloud-based environments, ensuring environments are protected from potential threats.

Integration and scalability: Wazuh can integrate with other security tools and expand its capabilities based on an organization's needs.

Security monitoring and log data analysis: Wazuh enables effective threat detection and response through log data analysis.

Security Integration Monitoring and Incident Response: Wazuh supports regulatory compliance monitoring and cloud security.

Security Tools, Log Control, and Incident Control: Wazuh provides tools for security, incident control, and log control.

Installation Wazuh by AWS

Step 1 "Launch Instance"

When logging into the AWS account, we select the EC2 service through Services or by the search box:

Click on Launch instance

Under Name and tags

Enter a name to identify your instance, For this tutorial, name the instance (Wazuh)

Under Application and OS Images:

From Quick Start, choose an AMI that meets your web server needs
Here we choose Ubuntu (which is free tier eligible)

Under Instance type:

Choose the type of instance, here we choose t2.medium.(It is recommended that the lowest specifications be 2CPU and 4GiB, which are available in the t2.medium or higher instance).

Under Key pair (login):

Choose the key pair

or create new key pair:
Give a name to the key pair, then click Create key pair

Under Network settings: under Firewall (security groups)

Choose to Create security groups
To Allow SSH traffic by clicking on the check box
To Allow HTTPS traffic from the internet by clicking on the check box

Leave all other configurations as they are (default settings)

In the Summary panel, review your instance configuration and then choose Launch instance.

Successfully initiated launch of instance and to see the instance click on the ID:

Your instance will first be Pending, and will then go into the Running state.

Step 2: "Connect to the instance"

To connect to your instance, select the instance and choose Connect.

There are many ways to connect to ec2, here we will choose the SSH client to connect.
After selecting the "SSH Client" section, copy and execute the following commands in the terminal as per the following steps:

Open Terminal (here we use Git Bash)

Change the directory with the cd command (change directory), where you have downloaded your pem file(key pair).

In this article, the pem file is stored in the downloads folder.

Execute the cd command to change the path to the location of the encryption key
cd Download/

Execute the following commands sequentially

Chmod 400 [key pair name].pem
ssh -i /path/key-pair-name.pem instance-user-name@instance-public-dns-name

After the command is executed you will be prompted to type “Yes” to continue with the connection

And that’s it! Now we’re logged in to our AWS instance.

Before installing Wazuh on an EC2 instance:

We get root permission by executing the sudo -i command

Step 3 "Install Wazuh"

Now to install Wazuh, execute the command curl -sO https://packages.wazuh.com/4.7/wazuh-install.sh&&sudo bash ./wazuh-install.sh -a -i

After some time has passed, the Wazuh installation is completed and we can log in using the username and password that we obtained with the installation:

Step 4 "login Wazuh"

Return to the AWS account and click on the instance
Then click on the details box
Then click on the public IPV4 address to open in a browser.

After opening the public IPV4 address in the browser, the following page appears, so we click on Advanced

then click below:

The wazuh construction steps have been completed successfully

We now login using the username and password that were obtained during the installation process previously:

You have successfully logged into Wazuh

References:

https://documentation.wazuh.com/current/installation-guide/wazuh-server/index.html

https://dev.to/zahraajawad/our-wordpress-site-installation-by-aws-34jn

BUILD, TAG, AND PUSH DOCKER IMAGES TO DOCKER HUB AND AMAZON ELASTIC CONTAINER REGISTRY

Zahraa Jawad — Fri, 22 Sep 2023 23:03:09 +0000

HEADLINES
 Docker Image Tag
 Tag an Image by Docker tag Command
 Simple steps to create an image and tag it
 Upload the image to Docker Hub
 Amazon Elastic Container Registry (ECR)
 Upload the image to Amazon Elastic Container Registry (ECR)

Docker Image Tag

In Docker, a "Tag" is an identifying tag attached to a Docker image to distinguish it from different versions of the same image or to specify other uses for it. The tag is appended to the image name with a validated comma (:) to create a unique name for this version or interpretation of the image. For example, if you are building a Docker image for a web application, you can assign a Tag to that image to tag different versions of the application.

• SOURCE_IMAGE is the name of the image you want to tag.
• TAG is the tag associated with the source image (optional).
• TARGET_IMAGE is the new name you want to give to the image.
• TAG is the new tag you want to assign to the image (optional).

In this example: the image named my-image with the tag latest is being tagged as my-image:v1.0 More than one tag can refer to the same image. Docker images can contain multiple tags pointing to the layers of the same image, allowing you to easily manage versions and references. Each image has a tag, so when the image is pulled without any tag, it pulls the latest. When specifying the tag, it removes the delimiter from it, for example, redis:alpain.

Tag an Image by Docker tag Command

We can explicitly tag the image with the Docker tag command. Tagging an image creates an alias for the name of the image. Here we will explore the way to tag an image.
Tag without name, by the command:
docker tag [image] [user name of docker hub/image]
For example:

When we run the docker Images command, we show that the image is tagged and takes the (latest) name because it has no name given.

Note: I used Docker installed on an instance in the AWS account, and this was explained in the article:

https://dev.to/zahraajawad/docker-basics-with-some-of-its-commands-and-how-to-install-docker-by-aws-7b6

Tag with name, by the command:
docker tag [image] [user name of docker hub/image]:[tag name]
For example:

And when we run the docker Images command, we show that the image is tagged and takes the name that is specified to it.

Now, to upload the image to Docker Hub (the account must be available on Docker Hub to be able to upload the image), you must first login to your Docker Hub account with the command:
docker login

Then enter your Docker Hub username and password:

Now the image can be uploaded to Docker Hub by command:
docker push [username/image]

To make sure the image has been pushed to Docker Hub, go to Account and note that the image has been pushed.

Dockerfile

Mind you, the application is still running on your machine, and you don’t have a Docker image yet. Of course, there are no magic wands you can wave at your app and turn it into a Docker container all of a sudden. You’ve got to write a Dockerfile and build an image out of it.
Docker’s official docs define Dockerfile as “a text document that contains all the commands a user could call on the command line to assemble an image.” Now that you know what a Dockerfile is, it’s time to write one.
Docker builds images by reading instructions in dockerfiles. A docker instruction has two components: instruction and argument.
A docker instruction can be written as :
RUN npm install“RUN” in the instruction and “npm install” is the argument. There are many docker instructions but below are some of the docker instructions you will come across often and the explanation. Mind you, we’ll use some of them in this post.

Docker Instructions

Simple steps to create an image and tag it

• Create a Dockerfile

Then the command cd to enter the directory:

Then by the command nano write the instructions needed to install and configure the application within the image

This file uses the latest Ubuntu image as a base and prints a simple sentence. After writing the necessary instructions for the image “This Is My Image!” . Then follow the steps to store and exit the file:
Ctrl+x : to exit
Y : to save then enter.

Building images:
Now build the image using the docker build command and command tag to add a name to the image
docker build - -tag [Image name]

The image is being built

After completing building the image, it can be displayed with some details through the docker Images command.

To run the image by the command docker run [image]

My Image implementation:

In the same manner as previously described, pushing to the Docker Hub can be made by logging into your Docker Hub account by the command docker login

Upload the image to Docker Hub:

After active login, you can upload the image to Docker Hub using the docker push command. Replace your docker-hub-username with your username on Docker Hub and your-image-name with the name you gave the image.

First, Execute the following commend:

and then executing a push command:

To confirm the upload:
After the upload is complete, you will be able to see the image on Docker Hub in your personal account, and everyone else can download the image from Docker Hub using docker pull using the full name of the image: docker.io/your-docker-hub-username/your-image-name. To make sure the image has been pushed to Docker Hub, go to Account and note that the image has been pushed.

More elements can be added to your Docker image definition to achieve more functionality. That is, you can build your image to achieve the functionality you need and build and test it well to make sure it works as expected. Here are some examples of what you can add: Install additional packages or software: You can install additional packages or software within the image using commands such as apt-get for Ubuntu systems.

Copy files to the image: You can copy files to the image using the copy instructions.

Define environmental variables: You can set environmental variables to configure the behavior of the image.

Run additional commands: You can set the commands that you want to be executed when the image is played.

Amazon Elastic Container Registry (ECR)

Amazon Elastic Container Registry (Amazon ECR) is a fully managed container registry offering high-performance hosting, so you can reliably deploy application images and artifacts anywhere.

Use cases:
• Manage software vulnerabilities
• Streamline your deployment workloads
• Manage image lifecycle policies

Upload the image to Amazon Elastic Container Registry (ECR):

Amazon Elastic Container Registry (ECR) is a managed AWS Docker registry service. In this topic, we will use the Docker CLI to push an image into Amazon ECR.

Here I am using Docker installed on an instance in my AWS account So, the first step here to upload the image to Amazon Elastic Container Registry (ECR) is to install the AWS Command Line Interface (CLI) to do the configuration with my AWS account.

To do this we follow the following steps:

• Install awscli in my instance by the commands:
Sudo apt update (To update the sudo library for Linux systems use APT)
Then the following command to install the awscli:
Sudo apt install awscli
• After the installation process, we perform the configuration process with the AWS account through the command aws configure

• Enter the user's access key, secret access key, and the AWS account region in which the repository will be built.

• Create a repository in ECR to which you will upload the image by the command:
aws ecr create-repository --repository-name my-repo-name --region your- region

To confirm that the repository has been created (ECR), go to Amazon Elastic Container Registry in your AWS account, and we will notice that the repository has been created successfully.

When you open the warehouse it is empty.

Now return to the command line interface to log in to the repository and upload our image.
• Log in to ECR to obtain a permit by the command:
aws ecr get-login-password --region your-region | docker login --username AWS --password-stdin your-account-id.dkr.ecr.your-region.amazonaws.com

• Describe the image using the address of the ECR repository you created:
docker tag my-image:latest your-account-id.dkr.ecr.your- region.amazonaws.com/my-repo-name:latest

• Now use the docker command to push the image to the ECR repository:
docker push your-account-id.dkr.ecr.your-region.amazonaws.com/my-repo-name:latest

• The image has been successfully uploaded to the repository in your AWS account.You can confirm by going to the repository in the account and noting the presence of the image.

References:
• https://dev.to/zahraajawad/docker-basics-with-some-of-its-commands-and-how-to-install-docker-by-aws-7b6
• https://stackify.com/docker-build-a-beginners-guide-to-building-docker-images/
• https://aws.amazon.com/ecr/

Docker Basics with some of its Commands and how to Install Docker by AWS

Zahraa Jawad — Fri, 18 Aug 2023 23:10:49 +0000

Outline
What do we mean by Docker?
How Docker works
Docker properties
Why use Docker
Some important terms in Docker
Install Docker on an Amazon Web Services (AWS) instance
Some basic commands for Docker

What do we mean by Docker?

Docker is an open-source platform used to build, run and manage applications inside containers. Where containers represent an isolated and lightweight environment that contains all the components needed to run a specific application, including source code, settings, libraries, tools, and the file system, and this makes them very similar to virtual machines (Virtual Machines), but they work more efficiently and quickly. Docker technology enables developers to uniformly develop and port applications between development, test, and production environments, reducing compatibility and dependency issues on specific environments. Developers can define the architecture of their applications using configuration files that define the required environment and settings, and then use Docker to create containers based on these definitions.

And it downloads to your operating system, be it Windows, Linux, Mac, or any other operating system
So, Docker is a tool through which containers are controlled.

How Docker works

Docker works by providing a standard way to run your code. Docker is an operating system for containers. Similar to how a virtual machine virtualizes (removes the need to directly manage) server hardware, containers virtualize the operating system of a server. Docker is installed on each server and provides simple commands you can use to build, start, or stop containers.
AWS services such as AWS Fargate, Amazon ECS, Amazon EKS, and AWS Batch make it easy to run and manage Docker containers at scale.

Docker properties

Each application that runs in the container will work in isolation from other applications in the rest of the containers, as it will be as if each application is running on an operating system alone, but the truth is that it is one operating system and all applications in the containers share it, and the Docker engine is the one that performs the management currency.
More than one container can run on a single operating system and is run by the Docker engine.
Applications can be run on Docker through containers on a private laptop, on a server, or on the cloud.

Why use Docker

Using Docker lets you ship code faster, standardize application operations, seamlessly move code, and save money by improving resource utilization. With Docker, you get a single object that can reliably run anywhere. Docker's simple and straightforward syntax gives you full control. Wide adoption means there's a robust ecosystem of tools and off-the-shelf applications that are ready to use with Docker.

- Ship more software faster
Docker users on average ship software 7x more frequently than non-Docker users. Docker enables you to ship isolated services as often as needed.

- Standardize Operations
Small containerized applications make it easy to deploy, identify issues, and roll back for remediation.

- Seamlessly move
Docker-based applications can be seamlessly moved from local development machines to production deployments on AWS.

- Save money
Docker containers make it easier to run more code on each server, improving your utilization and saving you money.

Some important terms in Docker

Image:
It is a template of code that cannot be modified. It is manufactured by other people or companies, such as Odoo, sonarqube, Ubuntu, Nginx, and others. It contains some instructions on how to create a Docker container through it.
The Docker image is all the things you need to run the application and it is light and small in size and easy to use because it contains only what the application needs.

Docker container:
It is a piece of software, such as icons, files, etc., that you need to run your application, and a container is an image that runs.

Registry:
It is a repository or registry that contains all Docker images The Docker Hub (https://hub.docker.com/) is a repository for all images created and supported by Docker and is available for anyone to use.

Client:
It is the primary means by which a user can interact with Docker to run commands, for example, pull, build, run, and others.
Which is a graphical interface, CLI, or something else, Docker uses an API to execute instructions or commands.

Docker demand:
It is a listener that waits for the command to be executed
If the image is on your local device, it creates a container from it, and more than one container can be run from the same image
If the image is not present, he will go to the registry ( Docker Hub ) and pull it from there.

Namespace:
Docker uses a technology called namespaces to provide the isolated workspace called the container, when you run a container, Docker creates a set of Namespace for that container. These Namespace provide a layer of isolation. Each aspect of a container runs in a separate namespace and its access is limited to that namespace.

Docker tag:
It is the address or reference to the docker image
More than one tag can refer to the same image. Docker images can contain multiple tags pointing to the layers of the same image, allowing you to easily
manage versions and references. Each image has a tag, so when the image is pulled without any tag, it pulls the latest. When specifying the tag, it removes the delimiter from it, for example, redis:alpain.

Image layers
Any change that happens or is made to the image is called a layer, which means that every command you specify (from, RUN, COPY, etc.) is a layer, and the sum of all layers is called a Dockerfile.

Dockerfile:
Is a text document that contains all the commands a user could call on the command line to assemble an image.
Dockerfile can build images automatically by reading the instructions from a Dockerfile.

Install Docker on an Amazon Web Services (AWS) instance

To install Docker on an Amazon Web Services (AWS) instance, you can follow these steps: Log in to the AWS Control Panel:
-Start logging in to your AWS account through the Control Panel (AWS Management Console).

Create an EC2 instance:

Go to the EC2 section of the Control Panel.

Click on "Launch Instances" to start the EC2 instance creation.

Name and Tags, AMI selections:

-Give the instance a name.
-Choose Ubuntu (free tier eligible) or another operating system that supports Docker as the instance platform.

Installation configuration:

Choose the instance type (t2.micro-free tier eligible) or another type, and specify the required resources (such as processor type and memory size).

Choose your SSH key (key pair) if this was done previously, or create a new key and save it somewhere safe.

Follow the required steps until you reach the "Configure Security Group" section. In this section, make sure to configure Allow SSH port (port 22) to access the instance.

Instance launch:

Browse and confirm the settings, then click "Launch instance". Accessing the instance via SSH:

Successfully launch the instance is done, click on the instance ID.

Connect to the instance:
After you launch the instance, you can use your SSH key to connect to it.
First, choose the instance and the click on connect `

-In the terminal window, Use the following command:
-chmod 400 teste.pem
Then:
-ssh -i "teste.pem" ubuntu@ec2-3-110-86-76.ap-south-1.compute.amazonaws.com

Execute the command:
Sudo –i
"sudo": is short for "Super User Do", which is a command that allows regular users to execute certain commands with root user privileges.

Docker installation:
After connecting to the instance via SSH and obtaining the root privilege, use the following command automation to install Docker:

Docker experience: Run a simple test command docker -v to check that Docker is working properly and to see the Docker version:

Some basic commands for Docker

docker pull [image name]:tag

The docker pull command is used to download Docker images from a specified repository, where:

Image name: The name of the Docker image you want to pull.
tag: Optional tag (version) of the image. If not specified, it defaults to (latest).

For example:

This command will fetch the latest version of the Ubuntu image from the Docker Hub repository and store it on your local machine.

docker images

This command displays a list of all the images on your device with details such as the image's name, tag, and size.

docker rmi [image name:tag]
To remove one image. For example:

And again to display the images after removing by the command docker images

docker run [image name]
The docker run command is used to create and start a new Docker container based on a specified image. It allows you to run a command or process inside the container, and you can customize various aspects of the container's behavior using options.
For example:

To displays existing containers by the command:
docker ps –all

All containers can be shown even if there is more than one container for the same image by command: docker container ls –a

docker ps –a
To list all containers, including both running and stopped containers.

docker rm [container id]
To remove one or more container

Again, run the docker ps -a command to show that the container is not in the list and that it has been deleted:

You can also specify a custom command to run in the container:

In this case, the echo "Hello, Docker!" the command will be executed inside a new container based on the image.
The execution is Hello, Docker!

The docker run command can be customized using various options to control aspects such as networking, volumes, environment variables, ports, and more.

docker container –d [image]
The -d helps run the container in the background That is, when the screen is turned off by running the image and we open a new window, it remains present.

docker inspect [image]
The docker inspect command is used to obtain detailed information about a Docker container or image, including metadata, configuration, networking details, and more. It provides a comprehensive JSON-formatted output that can be useful for debugging, troubleshooting, or extracting specific information from Docker objects.

For example:

docker stats [container id ]
The docker stats command is used to display a live stream of resource usage statistics for running containers. It provides real-time information about the CPU, memory, network I/O, and block I/O usage of each container. This command can be useful for monitoring and understanding the resource consumption of your Docker containers.

For example:

docker --help
Running docker --help in the command line will provide you with a summary of the available Docker commands and their descriptions. However, the output might be quite extensive. Here's a simplified version of the output you might see:

and other commands ….

References:

https://aws.amazon.com/docker/

Our WordPress site installation by AWS

Zahraa Jawad — Thu, 03 Aug 2023 01:33:49 +0000

WordPress is a popular content management system (CMS) that allows users to create and manage websites without extensive coding knowledge. Originally developed as a blogging platform, WordPress has evolved into a versatile tool for creating websites of all kinds, from personal blogs to e-commerce sites to corporate portals. 43% of the web is built on WordPress. More bloggers, small businesses, including notable brands and publications such as The New York Times, Forbes, and Sony Music.

On a slightly more technical level, WordPress is an open-source content management system licensed under GPLv2, which means that anyone can use or modify the WordPress software for free. A content management system is basically a tool that makes it easy to manage important aspects of your website – like content – without needing to know anything about programming.
The end result is that WordPress makes building a website accessible to anyone – even people who aren’t developers.

WordPress is licensed under the General Public License (GPLv2 or later) which provides four core freedoms:

The freedom to run the program for any purpose.
The freedom to study how the program works and change it to make it do what you wish.
The freedom to redistribute.
The freedom to distribute copies of your modified versions to others. And the some Features of WordPress:

• Easy-to-use interface with a visual editor and drag-and-drop functionality.

• Thousands of customizable themes and plugins to enhance functionality and design.

• Built-in SEO tools to optimize content for search engines.

WordPress.org and WordPress.com

The difference between WordPress.org and WordPress.com in a lot more detail, but here’s the short version:

• WordPress.org, often called self-hosted WordPress, is free, open-source WordPress software that you can install on your own web host to create a website that’s 100% your own.

• WordPress.com is a for-profit, paid service that is powered by the WordPress.org software. It’s simple to use, but you lose much of the flexibility of the self-hosted WordPress. Most of the time, when people say “WordPress”, they mean the self-hosted WordPress available at WordPress.org. If you want to truly own your website, self-hosted WordPress.org is almost always the best option.

Secure and Reliable of WordPress

WordPress is highly secure and reliable, thanks to its dedicated team continuously working on improving its security features and addressing vulnerabilities. With regular updates, robust user authentication, and a vast plugin ecosystem for enhanced security, WordPress provides a trustworthy platform for businesses and bloggers to protect their valuable data and ensure a stable online presence.

Kinds of Websites that Can Make Using WordPress

Any type of website imaginable can be made with WordPress. Users from all over the world use WordPress to make money online. It's simple enough to quickly create small websites and flexible enough to run e-commerce operations.

Here are some of the types of websites you can build with WordPress:

• Start a blog
• Make a small business website
• Create an online store
• Build a membership community
• Sell online courses
• and many more

Creation of WordPress by AWS: A Step-By-Step:

Some simple steps that we will implement to install WordPress: begin, first create an AWS account if you don't already have one. This will give you access to all the necessary tools and services for deploying WordPress on AWS.

• launch an instance in your AWS account, This will provide the virtual server that will host your WordPress site.

• Connect to the instance

• Execute some commands to install WordPress, With WordPress installed, it's time to configure your site. This includes setting up your database, selecting a theme, and installing any necessary plugins.

• Log in to WordPress

Step 1: launch an instance in your AWS account

When logging into the AWS account, we select the EC2 service through Services or through the search box

Click on Launch instance

Under Name and tags

Enter a name to identify your instance, For this tutorial, name the instance (WordPress)

Under Application and OS Images:

From Quick Start, choose an AMI that meets your web server needs
Here we choose Ubuntu (which is free tier eligible)

Under Instance type:

Choose the type of instance, here we choose t2.micro (free tier)

Under Key pair (login):

Choose the key pair

or create new key pair

Give a name to the key pair, then click Create key pair

Under Network settings: under Firewall (security groups)

Choose to Create security groups
To Allow SSH traffic by clicking on the check box
To Allow HTTP traffic from the internet by clicking on the check box

Leave all other configurations as they are (default settings)

In the Summary panel, review your instance configuration and then choose Launch instance.

Choose View all instances to close the confirmation page and return to the console. Your instance will first be in a Pending state, and will then go into the Running state.

Step 2: Connect to the instance

To connect to your instance, select the instance and choose Connect.

There are many ways to connect to ec2, here we will choose the SSH client to connect.

After selecting the "SSH Client" section, copy and execute the following commands in the terminal as per the following steps:

Open Terminal (here we use Git Bash)

Change the directory with the cd command (change directory), where you have downloaded your pem file(key pair).
In this article, the pem file is stored in the downloads folder.

Execute the cd command to change the path to the location of the encryption key
cd Download/

Execute the following commands sequentially

1. Chmod 400 [key pair name].pem

2. ssh -i /path/key-pair-name.pem instance-user-name@instance-public-dns-name

After the command is executed you will be prompted to type “Yes” to continue with the connection

And that’s it! Now we’re logged in to our AWS instance.

Before installing WordPress on an EC2 instance:

We get root permission by executing the sudo -i command

Executing the command "sudo -i" means booting as root on Linux. The main feature of this command is that it gives you full admin (root user) privileges, allowing you to perform commands and operations that require root user privileges.

Update the list of online software repositories: to obtain the latest list of packages available for installation and update. This procedure helps to obtain the latest versions and updates for the programs installed on your system. This is done by executing the sudo apt-get update command

Step 3: Execute some commands to install WordPress

Execute the command: sudo apt install apache2 -y

Installs Apache Web Server (Apache HTTP Server) on Linux using a package manager Software APT (Advanced Packaging Tool) This command assumes that it is running on an APT-based system Ubuntu, Debian, or Linux-derived systems.
Once this command is executed, the system will download and install the Apache web server on your system, and you are all set
To use it to host web pages and web applications on your own server.

To make sure that the web server has been installed successfully, we go to the EC2 instance and copy the public IPv4 address to any browser. We note that the installation has been completed successfully.

Installing php runtime on our ec2 (because WordPress is built on PHP) and a MySQL connector for PHP)

sudo apt install php libapache2-mod-php php-mysql -y

Install MySQL server for the database, To create and manage databases on our server.

sudo apt install mysql-server -y

Change our MySQL authentication plugin to a MySQL native password so that we can log in to the MySQL server with a normal password which is what is required in order to install WordPress.

sudo mysql -i

To change how the root user account (root) in the MySQL database authenticates to the default user root ((localhost). It is assumed that you execute this command when you set up a new database for a WordPress website, for example.

ALTER USER 'root'@localhost IDENTIFIED WITH mysql_native_password BY ‘[any password]';

Our password here is “wordpresspassword”

Create a new database to use with WordPress

create database [Name your database];

The name of the database here is “ wordpressdatabase “

To assign all the privileges on the database to the user:

grant all privileges on [name of database].* to (root)‘root’@localhost;

Then exit from the MySQL prompt by the exit command or ctrl d from the keyboard.

Now go to install WordPress:

From the browser go to the https://wordpress.org/download./ and click on download and install and copy the download link.

Execute the wget command with the download link that we copied from the web page

wget https://wordpress.org/latest.tar.gz

Then unzip the file that we are downloaded

tar xzf latest.tar.gz

Now use the ls command to show the downloaded file

-To move the WordPress folder to the document root of Apache, by the command:
sudo mv wordpress/ /var/www/html/

Enter to the document root of apache /var/www/html/ by change directory command cd

-use the ls command to show the WordPress file is moving to the root of Apache /var/www/html/

Go back to the browser and type in our public ipv4 address / wordpress. It will open the WordPress installation screen.

Enter the database name, username, and password, then click on Submit

-It shows us there is an error that it is unable to write to the wp-confige.php file

-To fix this error, copy all the code and go back to the terminal

-Go to the WordPress directory and create the new file name wp-confige.php by the nano command :

Nano wp-confige.php

And past the code by ctrl u from the keyboard

-To exit from the file: from the keyboard by ctrl x then y (to save the file) then click enter

Click Run the installation and show then the error is fixed by the following screen appears.

By This screen, give a name to our site, username, and email, here we name the site "WPSite" and the user name “MyWordPress”.

The WordPress installation is in a success and click on Log in to go to the log in screen.

Enter the username or email and password to log in to the site

This is our WordPress Dashboard and we can begin our work

Important note: assign the instance an elastic IP address to be static so anyone can know where our website is hosted, so need the IP address to be static. Note that attaching an elastic IP address is not free, but imposes a certain fee on it.

So, we attach a elastic IP address to the instance before we take the steps to connect to the instance, through the following steps:

On the left side of the instance dashboard, we choose elastic IPs

-Then click on Allocate Elastic IP address

• Created successfully
• Choose the IP and click on Action and choose Associate Elastic IP address

Define the instance type

2 . Choose the instance to which the elastic IP will be attached

3 . Click on Allocate

The elastic IP address is associated with the instance and will remain unchanged even when the instance is stopped and restarted.

References:

https://kinsta.com/knowledgebase/what-is-wordpress/

https://www.bluehost.com/blog/what-is-wordpress/

https://wordpress.org/about/

https://www.wpbeginner.com/beginners-guide/what-is-wordpress/

ENCRYPTION BY AWS KMS SERVICE

Zahraa Jawad — Thu, 20 Jul 2023 18:28:35 +0000

Outline

What is AWS KMS?
Comparison of AWS KMS with Other Encryption Services
Comparing Encryption Methods in AWS KMS
Best Practices for Securing Encrypted Data in AWS KMS
Advanced Encryption Techniques
How to generate AWS KMS encryption keys

What is AWS KMS?

AWS KMS Key Encryption (Key Management Service) is a service provided by Amazon Web Services (AWS) that allows the generation and management of keys to encrypt data in an AWS environment.
AWS KMS provides an API that can be used to create, import, and manage keys, as well as encrypt and decrypt data with those keys.
AWS KMS uses trusted encryption methods such as AES-256 to secure keys and data. This service allows the protection of sensitive data from unauthorized access and ensures compliance with security standards and applicable legislation.
With AWS KMS, private keys can be generated and stored in the secure service, and data is encrypted with these keys. KMS can also be used to control access to keys, manage key lifecycles, delegate access to keys, and monitor key-related activities.

In short, AWS KMS provides the ability to create and manage your own keys and encrypt data with those keys in a secure and trusted way in an AWS environment.

Comparison of AWS KMS with Other Encryption Services

AWS KMS
AWS Key Management Service (KMS) is a fully managed service that makes it easy to create and control the encryption keys used to encrypt your data. It integrates with other AWS services to provide seamless encryption for your data, and allows you to manage your encryption keys through the AWS Management Console, AWS CLI, or AWS SDKs.

Other Encryption Services
Other encryption services in the market include Microsoft Azure Key Vault, Google Cloud KMS, and HashiCorp Vault. These services offer similar functionality to AWS KMS, but may differ in terms of pricing, ease of use, and integration with other services.

Comparing Encryption Methods in AWS KMS

Best Practices for Securing Encrypted Data in AWS KMS:

Use Strong Access Controls

Ensure that only authorized users and services can access your encryption keys.
Use AWS Identity and Access Management (IAM) policies to restrict access to the KMS API and specific KMS keys.
Use AWS CloudTrail to audit key usage and changes.

Encrypt Your Data Before Storing It

Encrypt data before storing it in AWS KMS. This ensures that the data is protected even if the underlying storage is compromised.
Use client-side encryption libraries to encrypt data before sending it to AWS KMS.

Key Management

Follow the principle of least privilege when granting access to KMS keys.
Use AWS CloudTrail to monitor and log all key usage.
Rotate keys regularly to minimize the impact of a compromised key.

Encryption

Use envelope encryption to encrypt large amounts of data.
Encrypt data at rest using KMS-managed keys.
Use AWS KMS to encrypt data in transit.

AWS KMS: Advanced Encryption Techniques

Custom Key Management

A custom key store is a logical key store within AWS KMS that is backed by a key manager outside of AWS KMS that you own and manage. Custom key stores combine the convenient and comprehensive key management interface of AWS KMS with the ability to own and control the key material and cryptographic operations. AWS KMS allows for custom key management, giving users greater control over their encryption keys. Users can create and manage their own keys, or use AWS-managed keys for added convenience.

Envelope Encryption

AWS KMS supports envelope encryption, which adds an extra layer of security to encryption keys.
With envelope encryption, data is encrypted with a data key, which is then encrypted with a master key.
This provides an additional layer of protection, as the master key is never exposed to the data being encrypted.

How to generate AWS KMS encryption keys AWS

Log in to the AWS Management Console.
From Services or the box search to choose Key Management Service.

From navigate to the AWS KMS dashboard:
Choose customer managed keys

We note the previously created keys (key1)
To create a new encryption key, select Create key to create a new encryption key.

Note: We note that although the key was previously created, the deletion process continues Because the encryption key cannot be deleted directly, it takes at least seven days for the deletion process to be completed.

Key type:

We choose the type of encryption key, Symmetric or Asymmetric (here we will choose the symmetric encryption key).

Key usage:

Use the key only to encrypt and decrypt data.
Use the key only to generate and verify hash-based message authentication codes (HMAC).

Advanced options:

Key material origin - This is where you are using AWS KMS

- KMS: This means you creating the key management service on AWS

- External: This is if you using external which means if you have any symmetric 256 key management system you can bring it into your KMS.
- AWS CloudHSM key: if you are using the customer key store in CloudHsm

Choose the key generation Region:

Create a KMS key in a single AWS Region (by default)
Or generate a KMS key that you can replicate to multiple AWS Regions.
Then click on Next.

Add labels:
1. Provide a name for the key.

Description - (optional)
2. Put a Description for the key.

Tags:(optional)

You can use tags(Add Tag)to categorize and identify your KMS keys and help you track your AWS costs. When you add tags to AWS resources, AWS generates a cost allocation report for each tag.
Then click on Next.

Define key administrative permissions:

We choose the IAM users and roles that can manage this key through the KMS API. You may need to add additional permissions for users or roles to manage this key from this console.

Key deletion:

To allow key administrators to delete this key, Choose the check box.

Define key usage permissions:

We define which IAM users and roles can use the KMS key for encryption operations.

Additional AWS accounts can be added that can use this key. (Administrators of the accounts you specify are responsible for managing the permissions that allow IAM users and their roles to use this key).
Then click on Next

Review:

Reviewing all created encryption key configurations.

The encryption key AWS KMS has been generated successfully

Some actions can be taken on the key such as enabling the key to be used for encryption, disabling the key, or deleting the key, we do this by checking the checkbox for the key and choosing from the Key action.

Encrypt Data with the CMK

After generating AWS KMS encryption keys, it can be used to encrypt sensitive application data stored in the volume storage in EC2 or databases or object stores such as S3 using AWS KMS.

For example, in the EC2 service, when an instance is created, the volume storage can be encrypted by selecting encryption in the encryption box.

Also, data can be encrypted when creating new volume storage through:

Select the checkbox for Encryption this value
Then choose the encryption key.

Sensitive application data stored in storage in object stores such as S3 can be encrypted with AWS KMS.
When creating the bucket:

Choose how to encrypt objects via AWS KMS
Choose the key generated by AWS KMS.
Then choose the encryption key that was generated.

Deletion of the Encryption key AWS KMS

You should delete a KMS key only when you are sure that you don't need to use it anymore. If you are not sure, consider disabling the KMS key instead of deleting it. You can re-enable a disabled KMS key and cancel the scheduled deletion of a KMS key, but you cannot recover a deleted KMS key. You can only schedule the deletion of a customer managed key. You cannot delete AWS managed keys or AWS owned keys.

However, you might choose to delete a KMS key for one or more of the following reasons:
• To complete the key lifecycle for KMS keys that you no longer
need
• To avoid the management overhead and costs associated with
maintaining unused KMS keys
• To reduce the number of KMS keys that count against your KMS key
resource quota.

To delete the encryption key:

• We select the key to be deleted by the checkbox.
• From the key action choose Schedule key deletion

From Schedule key deletion:

Enter a waiting period between 7 and 30 days (Since deleting a KMS key is disruptive and potentially dangerous, AWS KMS requires you to set a waiting period of 7 to 30 days. The default waiting period is 30 days).
Then choose the checkbox to confirm the schedule key deletion
Then click on Schedule deletion.

Successfully scheduled deletion of key and you can note that from the status of the key (Pending deletion)

References:

WHAT ARE CRYPTOGRAPHY AND CRYPTOGRAPHY IN AWS

Zahraa Jawad — Fri, 09 Jun 2023 19:13:54 +0000

Outline

Encryption
Stages of data encryption
Key generation
Encryption in AWS
AWS Key Management Service (AWS KMS)

Encryption
Encryption refers to the conversion of files or data from one state to another while it is being transferred from one place to another or from one point to another to prevent it from being viewed except by the authorized person, where files are converted from readable file to unreadable unless decryption keys are used by the authorized person or entity. In general, encryption ensures the confidentiality and security of information and communications and contributes to the protection of privacy and the preservation of data integrity.

There are states and types of encryption:

- Encryption in transit:
When transferring with encryption keys, keys are used to encrypt and decrypt the data during the transmission. Encrypting data with a key means converting data into a form that is unreadable unless the correct key is present. When the data is received at the intended end, the correct key is used to decrypt it and restore it to its original state This is done while transferring data and files from one point to another.

- Encryption at rest:
Encryption during storage after delivery.

Stages of data encryption

Data and files before encryption are called plain text, i.e. plain text, images, video, or any form of data. After the encryption process, they are called cipher text, i.e. encrypted data. When using the decryption key, the data returns to its original state as plain text.

There are two types of encryption:

Symmetric encryption: With this encryption, the same key is used for encryption and decryption.

Asymmetric encryption: Two keys are used, one for encryption and one for decryption

Key generation

Key generation is the process of creating cryptographic keys used in various cryptographic algorithms and protocols. Cryptographic keys are essentially a string of random bits that serve as inputs to encryption and decryption algorithms.
A device or program used to generate keys is called a key generator or keygen.

Encryption in AWS

In the services provided by AWS, AWS supports both symmetric keys and asymmetric keys for encryption, and there are some services that use symmetric keys in encryption operations, and some other services that use asymmetric keys.

AWS also has other services that provide multiple encryption options using both symmetric and asymmetric keys, such as AWS CloudHSM, Amazon Kinesis, Amazon EKS, and others. See the official AWS documentation and developer guides for more details on how symmetric and asymmetric keys are used in specific services.

AWS encryption keys are used in AWS services:

Symmetric Keys:
• Amazon S3: Managed S3 Server-Side Encryption with symmetric keys can be used to encrypt data stored in an S3 bucket.
• Amazon EBS: EBS supports symmetric keys for storage disk encryption.
• Amazon RDS: Symmetric keys can be used to encrypt databases in RDS.

2. Asymmetric Keys:
• AWS Key Management Service (KMS): KMS allows you to create and manage asymmetric keys, which can be used in different AWS services such as S3, EBS, RDS, and others.
• AWS Certificate Manager (ACM): ACM uses asymmetric keys to issue and manage digital certificates that are used to secure HTTPS connections.

AWS Key Management Service (AWS KMS)

In AWS there is the KMS (Key Management Service) and its function is to generate encryption keys and it is compatible with most other AWS services that need encryption. Which is a managed service that makes it easy to create and control the cryptographic keys that are used to protect your data. AWS KMS uses hardware security modules (HSM) to protect and validate your AWS KMS keys under the FIPS 140-2 Cryptographic Module Validation Program.

An AWS KMS key is a logical representation of an encryption key. It is an essential resource in AWS KMS. To use or manage KMS keys, AWS KMS is required. The following three types of KMS keys can be generated in AWS KMS:
• Client-managed key: Established by the organization.
• AWS managed key: Generated by AWS services that use KMS keys to encrypt enterprise service resources.
• AWS-owned key: KMS keys created by AWS services in a service account.

Other uses of AWS KMS include:
• Protect your data at rest
• Encrypt and decrypt data
• Sign and verify digital signatures
• Validate JSON web tokens using HMAC

References:

https://docs.aws.amazon.com/kms/latest/developerguide/overview.html

https://www.techtarget.com/searchaws/definition/AWS-Key-Management-Service-AWS-KMS

Linux and Cybersecurity

Zahraa Jawad — Sun, 21 May 2023 09:57:48 +0000

Outline

Meaning of Cybersecurity
What is Linux?
Linux and Cybersecurity
Basic Linux commands
Challenges and risks in Linux cybersecurity
The mitigate of challenges and risks in Linux cybersecurity

Meaning of Cybersecurity

If you are looking into becoming a professional in cybersecurity, it might benefit you to understand what is expected of you fully. Cybersecurity is the protection of devices and their associated data from coming into the possession of unauthorized individuals. Almost everything we do is online now due to convenience and efficiency. We shop online, we communicate online, and we store personal information and images online. This means that our credit cards, location, and personal information can all be accessed by strangers if they are not adequately protected.
To defend against these attempts to acquire our personal information, virtually every personal device on the planet has a security program installed. Favored anti-virus software like Kaspersky or Norton is used to protect against hostile programs or hacking attempts from trojan horse programs that piggyback on otherwise legitimate downloads.

This software has become such a critical component of our computer use that those who would exploit weaknesses in the system for their own gain have to constantly update and enhance their methods to get ahead of what protects us.
Cybersecurity professionals are the ones who not only create the software we use to protect our information but they also maintain it. When hackers develop new tactics for circumventing antiviral software or cybersecurity programs, professionals analyze the tactics and update the programs to defend against the new tactic. They even find themselves engaging in counter-hacking attempts when the stolen information is sensitive enough to warrant further investigation. Every major law enforcement agency in the world now has a cybernetic crimes division that employs cybersecurity professionals to conduct these investigations and follow the digital trail back to these hostile hackers.

What is Linux ?

An operating system is a software that controls the basic functions of a computer, such as managing memory, processing, and storage. Linux is one of the most popular open-source operating systems, which is used in many devices, and is characterized by its high security and ability to be customized and modified.

Linux and Cybersecurity

Linux is used by many cybersecurity experts and advanced computer users. Some of the reasons for the widespread use of Linux among cyber security experts and advanced computer users are:

1.Open-source: Linux is open-source, which means that its source code is freely available for anyone to view, modify, or distribute. This makes it easier for users to customize the operating system to their specific needs and allows developers to work together to improve its security and performance.

2. Security: Linux is considered to be more secure than other operating systems, such as Windows, because it is less susceptible to viruses and other forms of malware. This makes it an attractive option for cybersecurity experts who need to protect sensitive information and networks from cyber threats.

3. Cost-effective: Linux is free to download and use, which makes it a cost-effective option for individuals and organizations who want to save money on operating system costs.

4. Flexibility: Linux is highly customizable and can be tailored to meet the specific needs of different users, from home users to large corporations. This makes it a versatile option for advanced computer users and cybersecurity experts who need an operating system that can be adapted to their unique requirements.

5. Community: Linux has a large and active community of developers and users who work together to improve the operating system and provide support to each other. This makes it easier for advanced computer users and cybersecurity experts to find help and resources when they need it.

Basic Linux commands

A Linux command is a program or utility that runs on the CLI – a console that interacts with the system via texts and processes. It’s similar to the Command Prompt application in Windows. Linux commands are executed on Terminal by pressing Enter at the end of the line. You can run commands to perform various tasks, from package installation to user management and file manipulation.

Here, we will learn about some basic Linux commands that help improve your cybersecurity.

System Update

A system update is one of the essential commands that help improve cyber security in Linux. When the system is updated, security vulnerabilities are fixed, performance is improved, and features are developed, making the system more secure and stable.

Manage files and permissions

File and permission management commands help improve cybersecurity in Linux. The user can specify the appropriate permissions for files and folders and determine who can access them, which prevents intruders and hackers from accessing sensitive files.

File encryption

File encryption commands help improve cybersecurity in Linux. Encryption techniques are used to protect and secure sensitive files from hacking, and they can only be opened with a password or a private key.

Network control

Network commands help improve cyber security in Linux. These commands are used to control network connectivity, determine which devices are allowed access, and prevent unauthorized access and cyberattacks.

Email fraud

Phishing commands help improve cyber security in Linux. These commands are used to detect and prevent electronic fraud and cyberattacks before they occur and to identify and deal with the source of the attack.

Linux features in cybersecurity

Linux has many features that make it more secure, such as a secure file system, privilege control, and strong data encryption.
Linux also provides powerful tools to detect and deal with attacks and intrusions, such as security tools, rapid analysis, and advanced monitoring tools.

Linux security and networks

Linux is one of the best options for protecting networks and servers, as it is characterized by stability, high security, and full control over powers.
Linux also provides powerful features to protect networks, such as firewalls, access control, and detection of various intrusions and attacks.

Machine Learning and Cybersecurity in Linux

Linux has the ability to integrate machine learning into cybersecurity, where artificial intelligence and machine learning can be used to detect and deal with attacks and breaches.
Machine learning in Linux can also be used to analyze activity logs and identify unusual patterns and potential breaches.

Challenges and risks in Linux cybersecurity

Although Linux is an operating system, it has challenges and risks in cybersecurity.
Among the next challenges are cyberattacks that can be encountered and dealt with, as well as security holes that can be exploited to gain access to protected data.

• Vulnerabilities and Exploits: Linux, like any other operating system, can have vulnerabilities that cyber attackers can exploit. These vulnerabilities can exist in the Linux kernel, libraries, or various software packages. If left unpatched or unnoticed, they can lead to unauthorized access, data breaches, or system compromises.

• Malware and Ransomware: Although Linux is generally considered more secure than other operating systems, malware and ransomware targeting Linux systems do exist. Attackers can distribute malicious software that can compromise the integrity of the system, encrypt files, or even take control of the system for malicious purposes.

• Insider Threats: Insider threats refer to the risks posed by individuals within an organization who have authorized access to Linux systems. These insiders can intentionally or unintentionally misuse their privileges to gain unauthorized access, steal sensitive information, or disrupt system operations.

• Weak Configuration and Poor Security Practices: Inadequate system configuration and poor security practices can introduce vulnerabilities into a Linux environment. Examples include weak passwords, insecure network configurations, improper access controls, unpatched software, and a lack of monitoring or intrusion detection systems.

• Lack of User Awareness: Users of Linux systems, including administrators, developers, and end-users, can inadvertently introduce security risks. This can happen through actions such as downloading and installing untrusted software, visiting malicious websites, falling victim to social engineering attacks, or neglecting basic security practices.

• Supply Chain Attacks: Linux systems rely on numerous software packages, libraries, and dependencies obtained from various sources. Cyber attackers can compromise the integrity of these software components during the supply chain process, leading to the distribution of malicious code to Linux systems.

• Diverse and Fragmented Ecosystem:

Linux has a diverse ecosystem with multiple distributions, each with its own unique configuration and package management system. This fragmentation can make it challenging to ensure consistent security practices across different Linux environments, leading to potential vulnerabilities and inconsistent patch management.

• Limited Security Resources:

Linux distributions typically have smaller development and security teams compared to commercial operating systems. This limited resource pool can result in delayed vulnerability patching, slower response to emerging threats, and reduced overall security posture.

The mitigate of challenges and risks in Linux cybersecurity

It is important to follow security best practices, such as :
•regular system updates and patching
• implementing strong access controls
•using secure configurations
• monitoring system logs
• conducting security audits
• providing user education and awareness programs
Additionally, the leverage of security tools, such as firewalls, intrusion detection systems, and antivirus software, can further enhance the security of Linux systems.

Basic Commands of Linux:

Linux commands are powerful tools for interacting with the operating system and performing various tasks. Here are some basic Linux commands:

ls command:
[ ls ]
To list the files and directories inside any given directory.

Some options you can use with the ls command:

cd command:

change directory
This command will help you to change your current directory.
Some options you can use with the ls command:

cat command:
Concatenate, or cat, is one of the most frequently used Linux commands. It lists, combines, and writes file content to the standard output. To run the cat command, type cat followed by the file name and its extension.
For example:
cat filename.txt.

References:
1.https://www.hostinger.com/tutorials/linux-commands

2.https://buildmedia.readthedocs.org/media/pdf/lym/latest/lym.pdf

3.https://kingslanduniversity.com/best-linux-distros-cybersecurity/

4.https://centresofexcellencenb.ca/digitalinnovation/?learning_activity=introduction-to-linux-commands-in-cyber-security

Introduction to Containers

Zahraa Jawad — Sun, 07 May 2023 19:19:29 +0000

**Outline

 Introduction to Containers
 Container Architecture
 Benefits of Containers
 Container Orchestration
 Challenges of Containerization
 Introduction to AWS Container Types
 Docker Engine
 Choosing the Right Container Type
 The Future of Containers
 Conclusion**

Introduction to Containers

Containers are a type of virtualization technology that allows for the creation and deployment of applications in a lightweight, portable manner. Unlike traditional virtual machines, which require a full operating system to be installed, containers share the host operating system kernel, making them much more efficient and faster to deploy.
Containers also provide a level of isolation between applications, ensuring that they do not interfere with each other or with the host system. This makes them ideal for use in cloud computing environments, where multiple applications may be running on the same hardware.
The virtual machines and containers have differed in several ways, but the primary difference is that containers provide a way to virtualize an operating system (OS) so that multiple workloads can run on a single operating system instance. With VMs, the hardware is being virtualized to run multiple operating system instances.

Container Architecture

Containers are built using a layered architecture, with each layer providing a specific function. The base layer is the host operating system, followed by the container runtime, which manages the creation and execution of containers. On top of this is the container image, which contains all the necessary files and dependencies to run an application. Finally, the container itself is created from the image and can be customized with additional configuration settings. This layered approach allows for greater flexibility and scalability when deploying applications in containers.

Benefits of Containers

Containers offer several key benefits over traditional virtualization technologies. First and foremost, they are much more efficient and lightweight, allowing for faster deployment times and better resource utilization. They also provide a high level of portability, making it easy to move applications between different environments and platforms. Containers also offer greater flexibility and scalability, as they can be easily scaled up or down depending on demand. Finally, containers provide a higher level of security and isolation than traditional virtual machines, helping to protect against cyber threats and data breaches. Containers require less system resources than traditional or hardware virtual machine environments because they don't include operating system images. Applications running in containers can be deployed easily to multiple different operating systems and hardware platforms.

Container Orchestration

As the number of containers in an environment grows, managing them becomes increasingly complex. This is where container orchestration comes in, providing a way to automate the deployment, scaling, and management of containers across multiple hosts. Popular container orchestration tools include:
-Kubernetes
-Docker Swarm
-Apache Mesos.

These tools provide a range of features, such as :
-Automatic load balancing
-Service discovery
-Rolling updates make it easier to manage large-scale container deployments.

Challenges of Containerization

While containers offer many benefits, they also present several challenges that must be addressed.
One of the biggest challenges is managing container sprawl, as the number of containers in an environment can quickly become overwhelming. This requires careful planning and management to ensure that resources are used efficiently.
Another challenge is ensuring the security of containers, particularly when they are deployed in shared environments. This requires a range of security measures, such as network segmentation, access controls, and vulnerability scanning, to protect against cyber threats and data breaches.

AWS Container Types
AWS provides different types of containers for developers to choose from based on their specific needs. These containers are designed to provide a scalable and secure environment for running applications in the cloud. The most popular container types in AWS include:

Amazon Elastic Container Service (ECS)
Amazon Elastic Kubernetes Service (EKS)
AWS Fargate.

Each of these containers has its unique features and benefits that make them suitable for different use cases.

Amazon Elastic Container Service (ECS)

Amazon Elastic Container Service (ECS) is a fully managed container service that makes it easy to run, stop, and manage Docker containers on a cluster. With ECS, developers can deploy their applications quickly and scale them easily to meet changing traffic demands. ECS supports both Linux and Windows containers, and it integrates seamlessly with other AWS services like Elastic Load Balancing, Amazon CloudWatch, and AWS Identity and Access Management (IAM).

Amazon Elastic Kubernetes Service (EKS)

Amazon Elastic Kubernetes Service (EKS) is a fully managed Kubernetes service that makes it easy to deploy, manage, and scale containerized applications using Kubernetes on AWS.
EKS provides a highly available and secure platform for running Kubernetes clusters, and it integrates seamlessly with other AWS services like Elastic Load Balancing, Amazon CloudWatch, and AWS Identity and Access Management (IAM).

AWS Fargate

AWS Fargate is a serverless compute engine for containers that allows developers to run containers without having to manage the underlying infrastructure. With Fargate, developers can focus on building and deploying their applications without worrying about the servers or clusters they run on.
Fargate provides a secure and scalable environment for running containers, and it integrates seamlessly with other AWS services like Elastic Load Balancing, Amazon CloudWatch, and AWS Identity and Access Management (IAM).

Docker Engine

Docker Engine is an open source containerization technology for building and containerizing your applications .
Docker Engine acts as a client-server application with:
-A server with a long-running daemon process dockerd.
-APIs which specify interfaces that programs can use to talk to and instruct the Docker daemon.

A command line interface (CLI) client docker. The CLI uses Docker APIs to control or interact with the Docker daemon through scripting or direct CLI commands. Many other Docker applications use the underlying API and CLI. The daemon creates and manage Docker objects, such as images, containers, networks, and volumes.

Choosing the Right Container Type

When choosing a container type in AWS, developers should consider factors like the complexity of their application, the level of control they need over the underlying infrastructure, and the desired level of scalability and availability. For simple applications, AWS Fargate may be the best choice as it eliminates the need for managing infrastructure. For more complex applications, Amazon Elastic Container Service (ECS) or Amazon Elastic Kubernetes Service (EKS) may provide more control and flexibility.

The Future of Containers

Containers are rapidly becoming the standard for application deployment and management, with more and more organizations adopting containerization as a core part of their IT strategy. As container technology continues to evolve, we can expect to see even greater levels of efficiency, scalability, and flexibility. In the future, we may also see new use cases for containers, such as in the Internet of Things (IoT) and edge computing. With their lightweight and portable nature, containers are well-suited for these emerging technologies and could play a key role in shaping the future of computing.

Conclusion

AWS provides a wide range of container types that give developers the flexibility and scalability they need to run their applications in the cloud. By choosing the right container type based on their specific needs, developers can build and deploy their applications quickly and efficiently.
Whether it's Amazon Elastic Container Service (ECS), Amazon Elastic Kubernetes Service (EKS), or AWS Fargate, AWS has a container type that can meet the needs of any application.

References