Forem: Israel-Lopes

Working with EC2 from the command line

Israel-Lopes — Thu, 11 May 2023 17:29:58 +0000

If you landed here by parachute and don't know how to configure LocalStack to simulate an AWS environment, follow this post: Simulating AWS CLI with LocalStack

What is EC2?

EC2 (Elastic Compute Cloud) is a cloud computing service from Amazon Web Services (AWS) that allows you to create and manage virtual machine instances in the cloud. EC2 instances provide scalable and flexible computing resources, allowing you to run applications and workloads in a virtualized environment.

Let's move forward now.

To upload our simulated aws environment, do:

sudo docker run --rm -it -p 4566:4566 -p 4571:4571 localstack/localstack

Let's create our first EC2 in CLI. To get started, follow the steps described in the line below:

To create EC2:aws ec2 run-instances --image-id <ami-id> --instance-type <instance-type> --key-name <key-pair-name> --security-group-ids <security-group-id> --subnet-id <subnet-id> --count <number-of-instances>

To run the EC2 create command, we need to provide details like IAM image type, number of instances, security group, access keys and other options.

--image-id: The ID of the Amazon Machine Image (AMI) image that will be used to create the EC2 instance. The AMI is the foundation for the instance and defines the operating system and other preinstalled software.

--instance-type: The type of EC2 instance you want to create. The instance type determines the compute resources, such as CPU, memory, and storage capacity, available to the instance.

--key-name: The name of the key pair that you want to associate with the EC2 instance. This allows you to log into the instance using SSH (Secure Shell).

--security-group-ids: The security group ID that you want to associate the EC2 instance with. The security group defines the allowed traffic rules for the instance.

--subnet-id: The ID of the subnet (subnet) you want to launch the EC2 instance into. The subnet determines the network the instance will be placed on and can affect instance connectivity and availability.

--count: The number of EC2 instances you want to create. Specifies how many identical instances will be created.

We will then need to specify this information, let's follow below:

In order to choose our image for EC2, we can use the following command to list the images available on AWS: aws ec2 describe-images, note that it will return a very large json object with details of the image architecture.

Example of command output:

},
        {
            "Architecture": "x86_64",
            "CreationDate": "2023-05-11T09:57:08.000Z",
            "ImageId": "ami-fbc1c684",
            "ImageLocation": "None",
            "ImageType": "machine",
            "Public": true,
            "KernelId": "None",
            "OwnerId": "591542846629",
            "RamdiskId": "ari-1a2b3c4d",
            "State": "available",
            "BlockDeviceMappings": [
                {
                    "DeviceName": "/dev/xvda",
                    "Ebs": {
                        "DeleteOnTermination": false,
                        "SnapshotId": "snap-00e5f6c8",
                        "VolumeSize": 15,
                        "VolumeType": "standard"
                    }
                }
            ],
            "Description": "Amazon Linux AMI 2018.03.b x86_64 ECS HVM GP2",
            "Hypervisor": "xen",
            "ImageOwnerAlias": "amazon",
            "Name": "amzn-ami-2018.03.b-amazon-ecs-optimized",
            "RootDeviceName": "/dev/xvda",
            "RootDeviceType": "ebs",
            "Tags": [],
            "VirtualizationType": "hvm"
        },

Now we have to create a new security group, because it is he who will determine entry and exit rules. We must inform the name of the group we want to create and its description:

aws ec2 create-security-group --group-name MyGroupTest --description "group description"

Running the command returns something like this:

{
    "GroupId": "sg-0937433e1dbd16c91",
    "Tags": []
}

Keep the GroupId as it will be useful to create the EC2. If you already have a security-group already created, you can list them as follows: aws ec2 describe-security-groups. This will list all the groups you have.

We can also apply filters if you know the name of the group, in this case just use the name of the group we just created:

aws ec2 describe-security-groups --filters "Name=group-name,Values=MyGroupTest"

Let's move on.

Let's get the subnet-id, for that we can list them with the following:

aws ec2 describe-subnets

We can apply filters if we want too:

aws ec2 describe-subnets --filters "Name=subnet-id,Values=<subnet-id>"

I will use as an example the id "subnet-b8a4b5ff".

Let's get instance-type, just do the command to list:

aws ec2 describe-instance-types

In the return what interests us is the InstanceType field, it contains the name of the instance.

Finally, let's get the key-name, which is the name of the access key (key pair) that you will use to connect to the EC2 instance. This access key is a pair of public or private keys that are used to authenticate access to the EC2 instance.

If you already have one, we can list it as follows:

aws ec2 describe-key-pairs

In my case I don't have it yet, so I'll have to create one, follow the step:

aws ec2 create-key-pair --key-name MyKeyPairTest --output text > MyKeyPairTest.pem

This will create a new passkey called MyKeyPairTest and save the private key in the MyKeyPairTest.pem file, just be sure to save it in a safe place.

Now that we've collected all the necessary information, we can create EC2, mine looks like this:

aws ec2 run-instances \
  --image-id "ami-fbc1c684" \
  --instance-type "d3.2xlarge" \
  --key-name "MyKeyPairTest" \
  --security-group-ids "sg-0937433e1dbd16c91" \
  --subnet-id "subnet-b8a4b5ff" \
  --count 2

Now just run the command above to create our first EC2. Next step now and start our EC2 instance, just follow the example below:

aws ec2 start-instances --instance-ids <instance-id>

Standing as follows: aws ec2 start-instances --instance-ids "i-304d1f1933d722ab6"

This is the successful return we want to have:

{
    "StartingInstances": [
        {
            "CurrentState": {
                "Code": 0,
                "Name": "pending"
            },
            "InstanceId": "i-304d1f1933d722ab6",
            "PreviousState": {
                "Code": 16,
                "Name": "running"
            }
        }
    ]
}

Here we finish our learning about EC2.

Learn to use AWS IAM in command line

Israel-Lopes — Wed, 10 May 2023 20:33:05 +0000

If you landed here by parachute and don't know how to configure LocalStack to simulate an AWS environment, follow this post: Simulating AWS CLI with LocalStack

What is IAM?

IAM (Identity and Access Management) is an AWS service that allows you to securely manage access to AWS resources and services. It provides granular control over permissions and access policies for users, groups, roles, and services within your AWS account.

IAM lets you create and manage identities (users, groups, and roles) and assign
permissions specific to those identities. Some of the main features and
IAM features include:

User Management: You can create IAM users and provide credentials
login for them. Each user will have a set of unique credentials
to authenticate to the AWS account.
Groups: You can organize users into logical groups and assign permissions at the group level.
This simplifies permission administration as you can add or remove users from
a group and the permissions will be applied automatically.
IAM Roles: IAM roles allow you to grant temporary permissions to services and
AWS applications. This is useful when you want to allow a service to access
other resources in your account on your behalf, without having to share access credentials.
IAM Policies: IAM policies are JSON documents that define permissions for
users, groups, and roles. You can create custom policies to meet requirements
access specifics and assign those policies to identities.
Integration with Other Services: IAM integrates with many AWS services, allowing you to
control access to specific features in those services. For example, you can define policies
access to S3 buckets, EC2 instances, SQS queues and many others.

Creating user in IAM

Now let's learn how to create our first user in IAM, just follow the command below:

aws iam create-user --user-name <username>

We can now list our user: aws iam list-users

After the user has been created, we can now grant access to him. Here's an example:

aws iam attach-user-policy --user-name <username> --policy-arn arn:aws:iam::aws:policy/MyPolicy

Replace <username> with the username you created and
arn:aws:iam::aws:policy/MyPolicy by the ARN (Amazon Resource Name) of the
policy you want to associate.

Below is a list of the most common policies to apply:

AmazonS3FullAccess: Grants full access to Amazon S3 storage services.
- AmazonEC2FullAccess: Grants full access to Amazon EC2(Elastic Compute Cloud) services.
- AmazonDynamoDBFullAccess: Grants full access to Amazon DynamoDB services.
- AmazonRDSFullAccess: Grants full access to Amazon RDS (Relational Database Service) services.
- AmazonSQSFullAccess: Grants full access to Amazon SQS (Simple Queue Service) services.
- AmazonSNSFullAccess: Grants full access to Amazon SNS (Simple Notification Service) services.
- AWSLambdaFullAccess: Grants full access to AWS Lambda services.
- AWSReadOnlyAccess: Grants read-only access to a wide range of AWS services.

If you want to see more policies, access the link politicas
Continuing, I want to give access to the user Luis to have access to Dynamo, in this case:

aws iam attach-user-policy --user-name Luis --policy-arn arn:aws:iam::aws:policy/AmazonDynamoDBFullAccess

Now let's list the accesses of our user Luis:

aws iam list-attached-user-policies --user-name Luis

It will return the following:

{
    "AttachedPolicies": [
        {
            "PolicyName": "AmazonDynamoDBFullAccess",
            "PolicyArn": "arn:aws:iam::aws:policy/AmazonDynamoDBFullAccess"
        }
    ]
}

I want to remove the access that I was given to the user, how do you do it now?
Just follow the example, let's remove the access we just gave Luis:

aws iam detach-user-policy --user-name Luis --policy-arn arn:aws:iam::aws:policy/AmazonDynamoDBFullAccess

Listing the user accesses, it should return:

{
    "AttachedPolicies": []
}

This way, we just detach AmazonDynamoDBFullAccess access to the user Luis.
We move on now.

Now let's delete the user Luis:

aws iam delete-user --user-name Luis

Finish

We learned here how to create users, set access policies, remove them and delete users.
There are more features that IAM can offer, but I've only presented the basics.

Simulating s3 bucket on localhost

Israel-Lopes — Wed, 10 May 2023 14:06:10 +0000

If you landed here by parachute and don't know how to configure LocalStack to simulate an AWS environment, follow this post: Simulating AWS CLI with LocalStack

What Bucket S3?

Bucket S3 (Amazon Simple Storage Service) and a cloud storage container. A good one
analogy we can do and that Bucket S3 would be a directory in a linux environment in which you
can create the boards that would be the bucket, and within the directors the data files that
You want to store. You don't need much attention to realize that the bucket commands are
similar to the commands of listing and deleting on Linux.

Now we follow the tutorial.

Here we will learn:

Create Bucket
climb files to the bucket
List Buckets and Files
Delete Bucket files

To facilitate learning and is similar to the service of Amazon, let's create an alias.

Inside I give your .Bashrc or another preferably, paste the follownet code.



source /home/oem/Workspace/myenv/venv/bin/activate
alias aws="aws --endpoint-url=http://localhost:4566"

Do not forget to load the file: source ~/.BASHRC

In this way we are overcrowding the AWS command to that of Locastack. Now in the
do:

aws --endpoint-url=http://localhost:4566 s3 mb s3://my-bucket-to-test

Now it will be that way: AWS S3 MB S3: // My-Bucket-to-Test, so we can create our Bucket S3.

If you want, you can subscit the name "My-Bucket-To-Test" for the bucket name you want.

When creating Bucket he had returned the message "Make_Bucket: My-Bucket-To-Test" on the prompt output.
Here we will exemplify some ways to climb files to Bucket S3.

Bucket Upload

Now let's are in the bucket data mass, so it will climb all files that
are within the specified directory.

aws s3 sync /home/oem/Workspace/local-stack-aws/bucket-s3/ s3://my-bucket-to-test/

When uploading to Bucket, the file will be stored with the same board structure. my
It was as follows:

aws s3 sync /home/oem/Workspace/local-stack-aws/bucket-s3/product_data.json s3://my-bucket-to-test/

If you want to climb only one file, we can do it like this:

aws s3 cp /home/oem/Workspace/local-stack-aws/bucket-s3/product_data.json s3://my-bucket-to-test/

Now that we go up it let's go Baixalo:

Bucket download

aws s3 cp s3://my-bucket-to-test/product_data.json - | cat

This command assigns the Product_Data file and Cat on its exit, returning the object.

deleting bucket file

First let's list our bucket:

aws s3 ls s3://my-bucket-to-test/

Now that we already know which one delete, let's go on:

aws s3 rm s3://my-bucket-to-test/product_data.json

Upon running the command it returns the following message:

delete: s3://my-bucket-to-test/product_data.json

We just said that we want to delete the Product_Data.json file of our Bucket. If we list the
Content of our Bucket again, we will see that it no longer exists.

Simulating AWS CLI with LocalStack

Israel-Lopes — Tue, 09 May 2023 15:32:26 +0000

S3 (Simple Storage Service)
IAM (Identity and Access Management)
EC2 (Elastic Compute Cloud)
Lambda
DynamoDB
API Gateway
CloudFormation
CloudWatch
SQS (Simple Queue Service)
SNS (Simple Notification Service)
Elastic Beanstalk
KMS (Key Management Service)
Cognito

Dependencies:

AWS CLI
Docker
Python 2.7.x or Python 3.4
python3-pip
python3-venv

To simulate the aws environment locally and very simply, first we have
to install the AWS CLI as follows:

Install the AWS CLI using a method appropriate for your operating system.

download aws-cli

As my system is Linux, I will follow other steps as follows:

If you don't have python on your machine, just follow

sudo apt-get update && sudo apt-get install python3 && sudo apt install python3-pip

Now install AWS CLI using virtual environment.

Make sure you have the python3-venv package installed by running the following command:

sudo apt install python3-venv

Create a new directory where you want to create the virtual environment. For example:

mkdir myenv

Enter the cd myenv directory

Create a virtual environment using the following command: python3 -m venv venv

Activate the virtual environment by running the command, whenever you want to run the AWS CLI, you will need
than run this command from the virtual environment:

source venv/bin/activate

then just install awscli in isolation so you don't run the risk of
dependency conflicts.

pip install awscli

Keep in mind that whenever you need to use the AWS CLI, you will first need to enable
virtual environment using the source venv/bin/activate command.

After the installation is complete, you can verify that the AWS CLI installed correctly
typing the following command:

aws --version

Install Docker in your local environment, if not already installed.
Download and install LocalStack using Docker Hub. For example, you can run the following command in the terminal:

docker run --rm -it -p 4566:4566 -p 4571:4571 localstack/localstack

When executing the command, if it returns this information, it means that it is roaming:

LocalStack version: 2.0.3.dev
LocalStack build date: 2023-05-06
LocalStack build git hash: 3e778577

2023-05-09T14:59:48.980 INFO --- [-functhread3] hypercorn.error : Running on https://0.0.0.0:4566 (CTRL + C to quit)
2023-05-09T14:59:48.980 INFO --- [-functhread3] hypercorn.error : Running on https://0.0.0.0:4566 (CTRL + C to quit)
Ready.

This will launch the LocalStack container and expose ports 4566 and 4571,
that are used to access the simulated services.

Now you can use AWS CLI or SDKs to connect to LocalStack and interact
with simulated services. Be sure to set the region to
"us-east-1" and the endpoint to "http://localhost:4566" when using the AWS CLI or SDKs.

For example, to list Amazon S3 buckets using the AWS CLI:

aws --endpoint-url=http://localhost:4566 s3 ls

This command will give an error because first we have to configure aws-cli on our machine. let's go to
next step.

AWS CLI Configuration

Now we have to configure aws-cli before using it.

Run the aws configure command

It will ask for the following information:

AWS Access Key ID: Enter your AWS account access key ID.
AWS Secret Access Key: Enter the secret access key corresponding to the access key ID provided earlier.
Default region name: Enter the AWS region you want to use (for example, "us-east-1" or "eu-west-1").
Default output format: Choose a preferred output format, such as "json", "text" or "table".

After entering all the necessary information, the credentials will be configured and
stored in a configuration file in the AWS CLI directory.

Now you can start using LocalStack to interact with AWS services.
For example, you can list Amazon S3 buckets using the following command:

As with aws-cli: aws s3 ls

With local-stack: aws --endpoint-url=http://localhost:4566 s3 ls

This will return a list of buckets available in your AWS account.

Each AWS service has its own specific commands and options that can
be explored in the official AWS CLI documentation.

Let's now create a bucket for demo usage

aws --endpoint-url=http://localhost:4566 s3 mb s3://my-bucket-to-test

If you want, you can replace the name "my-bucket-to-test" with the name of the bucket you want.

When creating a bucket, it will return the message "make_bucket: my-bucket-to-test" in the prompt output.

Now we can list our bucket:

aws --endpoint-url=http://localhost:4566 s3 ls

will return "2023-05-09 12:15:00 my-bucket-to-test"

Finish

Remember that when running, you must first load the virtual environment and run the container:

source venv/bin/activate

docker run --rm -it -p 4566:4566 -p 4571:4571 localstack/localstack

Factory Design Pattern: #2

Israel-Lopes — Mon, 08 May 2023 09:37:14 +0000

// Interface Product
public interface Product {
    void doSomething();
}

// ConcreteProductA implementation class
public class ConcreteProductA implements Product {
    @Override
    public void doSomething() {
        System.out.println("Doing something in ConcreteProductA");
    }
}

// ConcreteProductB implementation class
public class ConcreteProductB implements Product {
    @Override
    public void doSomething() {
        System.out.println("Doing something in ConcreteProductB");
    }
}

// Classe Factory
public class ProductFactory {
    public static Product createProduct(String type) {
        if (type.equalsIgnoreCase("A")) {
            return new ConcreteProductA();
        } else if (type.equalsIgnoreCase("B")) {
            return new ConcreteProductB();
        }
        throw new IllegalArgumentException("Invalid product type: " + type);
    }
}

public class Main {
    public static void main(String[] args) {
        Product productA = ProductFactory.createProduct("A");
        productA.doSomething();

        Product productB = ProductFactory.createProduct("B");
        productB.doSomething();
    }
}

In this example, we have a Factory pattern that allows us to create different types of products (Product) using a factory (ProductFactory).

The Product interface defines common behavior for all products. Next, we have the ConcreteProductA and ConcreteProductB classes that implement the Product interface with specific behaviors.

The ProductFactory class is the factory responsible for creating product instances. It has a static method createProduct() that receives a type parameter indicating the desired product type. Based on that type, the factory instantiates and returns an object of the correct type. In the example, we have the creation of ConcreteProductA for type "A" and ConcreteProductB for type "B".

Finally, in the main() method of the Main class, we demonstrate how to use the factory to create the desired products. We create a product A with ProductFactory.createProduct("A") and a product B with ProductFactory.createProduct("B"). Next, we call the doSomething() method on each product, which performs each product's specific behavior.

The Factory pattern is useful when you need to create objects of different related classes, but only know the required object type at runtime. The factory abstracts object creation, allowing you to work with the common interface (Product) instead of specific implementations. This makes the code more flexible and makes it easier to add new product types in the future.

____________________<< go to back__________________

Singleton Design Pattern: #1

Israel-Lopes — Mon, 08 May 2023 03:19:17 +0000

The Singleton design pattern is used to ensure that a class has only one instance for the entire program run and to provide a global point of access to that instance.

There are several situations where the Singleton pattern is useful:

Management of Shared Resources: If you have a resource that needs to be shared by multiple pieces of code, such as a database connection, a log object, or a thread pool, Singleton can ensure that there is only one instance of that resource. resource and that it is globally accessible.
Concurrent Access Control: Singleton can be used to control concurrent access to a shared resource. By having a single instance, you can ensure that concurrent access is coordinated and that operations are performed securely.
Access to global settings or information: If you have global information or settings that need to be accessed from different parts of the program, Singleton can provide a centralized point to access that information.

It is important to keep in mind that the use of the Singleton pattern must be careful, as it can introduce coupling and make the code difficult to test. In addition, it is essential to consider your system's specific requirements and characteristics before deciding to use a Singleton.

In Java, Singleton can be implemented by ensuring that the class has a private constructor, a static method to get the single instance, and a private static variable to hold that instance. In this way, the Singleton can control instance creation and provide global access to the instance.

Let's see an example of its use below:

public class Logger {
    private static Logger instance;

    private Logger() {
        // logger initialization
    }

    public static Logger getInstance() {
        if (instance == null) {
            synchronized (Logger.class) {
                if (instance == null) {
                    instance = new Logger();
                }
            }
        }
        return instance;
    }

    public void log(String message) {
        // Lógica para registrar o log
        System.out.println("Log: " + message);
    }
}

In this example, the "Logger" class implements the Singleton pattern to ensure that only one logger instance is created during program execution.

You can use it as follows in your code:

Logger logger = Logger.getInstance();
logger.log("log message");

That way you get the single instance of the logger and you can call the "log" method to record your log messages.

The Singleton pattern is commonly used in scenarios where you need a single shared instance of a class across the entire application. The above "Logger" example is just an illustrative example, but you can find the Singleton pattern being used in many libraries and frameworks to provide global access to resources such as database connection pools, caches, settings, etc.

└─ Main
   └─ main(String[] args)
      └─ Logger
         ├─ instance: Logger
         └─ getInstance(): Logger
            └─ instance: Logger
               └─ new Logger()

In this example, we have the Main class with the main method as the root node. Inside the main method, the Logger class is used.

The structure of the Singleton pattern is represented by the following elements:

Logger is the class that implements Singleton.
instance is a static attribute of the Logger class that represents the single instance of the class.
getInstance() is the static method of the Logger class which is responsible for returning the existing instance or creating a new one, if necessary.
When the getInstance() method is called for the first time, a new instance of the Logger class is created and assigned to instance. In subsequent calls to getInstance(), the existing instance is returned.

public class Logger {
    private static Logger instance;

    private Logger() {
        // logger initialization
    }

    public static Logger getInstance() {
        if (instance == null) {
            synchronized (Logger.class) {
                if (instance == null) {
                    instance = new Logger();
                }
            }
        }
        return instance;
    }

    public void log(String message) {
        // Lógica para registrar o log
        System.out.println("Log: " + message);
    }
}

public class Main {
    public static void main(String[] args) {
        Logger logger = Logger.getInstance();
        logger.log("log message");
    }
}

____________________<< go to back__________________

Design Patterns

Israel-Lopes — Mon, 08 May 2023 02:55:22 +0000

Introduction

What are design patterns?

Design patterns, or design patterns, are reusable solutions to common problems that arise during software development. They are proven and tested solutions that help developers create cleaner, more flexible and maintainable code.

Design patterns provide a set of guidelines and abstractions that can be applied to different situations to solve specific problems. They are not ready-to-use snippets of code, but concepts and ideas that can be implemented according to the needs of each project.

There are several types of design patterns, which can be categorized into three main groups:

Creation Patterns: These patterns deal with the creation of objects, providing flexible mechanisms for creating instances of classes. Some examples include the Factory Method, Abstract Factory, Singleton, and Builder pattern.
Structural Patterns: These patterns deal with composing classes and objects to form larger structures. They help ensure that classes and objects work together efficiently. Some examples include the Adapter, Decorator, Composite, and Proxy pattern.
Behavioral Patterns: These patterns deal with the interaction between objects and the distribution of responsibilities between them. They are useful for defining how objects communicate and interact with each other. Some examples include the Observer pattern, Strategy, Template Method and Command.

Below are some design patterns:

Singleton Design Pattern: This pattern is used to ensure that a class has only one instance and provides a global point of access to that instance.
Factory Design Pattern: The Factory pattern is used to create objects without specifying the exact class of the object to be created. This provides an abstraction and flexibility in creating objects.
Observer Design Pattern: This pattern is used to implement the event and notification system, where an object (observer) maintains a list of other objects (observed) and is automatically notified of any state change in these objects.
Strategy Design Pattern: The Strategy pattern allows you to define a family of algorithms, encapsulate each one of them and make them interchangeable. This allows the algorithm to be selected at runtime based on requirements.
Decorator Design Pattern: The Decorator pattern is used to dynamically add functionality to an object. It allows extending the functionalities of an object without having to modify its structure.
Composite Design Pattern: The Composite pattern is used to create hierarchical tree structures. It lets you treat individual objects and collections of objects uniformly.
MVC Design Pattern (Model-View-Controller): The MVC pattern is used to separate business logic (Model), data presentation (View) and user interaction (Controller). This helps maintain an organized structure and makes the code easier to maintain and evolve.
DAO (Data Access Object) Design Pattern: The DAO pattern is used to separate data access logic from business code. It provides an abstraction for interacting with the database, allowing easy switching of data storage technologies without affecting the rest of the code.
Builder Design Pattern: Used to build complex objects step by step, allowing different representations of the same object.
Prototype Design Pattern: Allows the creation of new objects by cloning an existing object, avoiding the creation of several subclasses.
Adapter Design Pattern: Used to allow classes with incompatible interfaces to work together through an intermediate adapter.
Proxy Design Pattern: Provides a surrogate or surrogate for another object to control access to it.
Facade Design Pattern: Provides a simplified interface for a complex set of subsystems, making them easier to use.
Template Method Design Pattern: Defines the structure of an algorithm in a superclass, allowing subclasses to override specific algorithm steps.
Command Design Pattern: Encapsulates a request as an object, allowing you to parameterize clients with different requests and queue or log requests.
Iterator Design Pattern: Provide a uniform way to access the elements of a collection, without exposing its underlying implementation.

Open/Closed Principle: 2#

Israel-Lopes — Sun, 07 May 2023 13:47:23 +0000

Open/Closed Principle: Software entities (classes, modules, functions, etc.) must be open for extension but closed for modification. This means that you should be able to extend an entity's behavior without modifying its existing source code. This promotes code reuse and modularity.

Let's go to an example of the applicability of this concept.

Suppose we have a system where we have different types of employees, such as RegularEmployee and Manager, and we need to calculate the salary for each of them based on different criteria. Let's start with a simple implementation without considering the Open/Closed Principle:

public class Employee {
    private String name;
    private double salary;

    // Constructor, getters, and setters omitted for simplicity

    public double calculateSalary() {
        return salary;
    }
}

public class Manager extends Employee {
    private double bonus;

    // Constructor, getters, and setters omitted for simplicity

    @Override
    public double calculateSalary() {
        return super.calculateSalary() + bonus;
    }
}

In this case, we have the class Employee as the base and the class Manager as an extension of it. Each class has its own calculateSalary() method, where Manager adds a bonus to the base salary.

However, this implementation does not follow the Open/Closed Principle because if a new type of employee emerges, we would have to modify the existing Employee class. Let's refactor the code to follow the Open/Closed Principle using interfaces and polymorphism:

public interface Employee {
    double calculateSalary();
}

public class RegularEmployee implements Employee {
    private String name;
    private double salary;

    // Constructor, getters, and setters omitted for simplicity

    @Override
    public double calculateSalary() {
        return salary;
    }
}

public class Manager implements Employee {
    private String name;
    private double salary;
    private double bonus;

    // Constructor, getters, and setters omitted for simplicity

    @Override
    public double calculateSalary() {
        return salary + bonus;
    }
}

Here, we introduced the Employee interface that defines the calculateSalary() method. Then, we implemented the RegularEmployee and Manager classes that implement this interface.

Now, if we want to add a new type of employee, such as an Intern, we can create a new class that implements the Employee interface without modifying the existing classes:

public class Intern implements Employee {
    private String name;
    private double stipend;

    // Constructor, getters, and setters omitted for simplicity

    @Override
    public double calculateSalary() {
        return stipend;
    }
}

This way, by following the Open/Closed Principle, we can extend the behavior of the system by adding new types of employees without modifying the existing code.

___________<< back______________next page >>__________

Single Responsibility Principle: #1

Israel-Lopes — Sun, 07 May 2023 00:36:28 +0000

The first principle of SOLID is the Single Responsibility Principle (SRP). This principle states that each class should have only one specific responsibility, that is, a single task to perform.

SRP is considered fundamental in SOLID, as it provides significant benefits in terms of code maintenance and readability. I agree that the other SOLID principles are based on this first principle. Therefore, it is essential to respect and strictly apply the SRP, as this allows for the proper implementation of the other principles.

_____________________next page >>____________________

Microservice: Monitoring and Observability #7

Israel-Lopes — Tue, 02 May 2023 12:59:48 +0000

Monitoring is the process of collecting data about system performance and availability. This includes metrics, logs, and events that can be used to identify issues and monitor the state of the system. Monitoring allows teams to identify performance and availability issues, as well as trends over time.

Observability, on the other hand, is the ability to understand the behavior of the internal system based on its external signals, including logs, metrics and events. This involves collecting detailed information about the state of the system in real time, allowing operations and development teams to understand how the system is behaving and detect problems more quickly and effectively.

Observability is particularly important in microservice environments, where many services are interconnected and constantly changing. Observability allows teams to monitor the state of each service individually, as well as the system as a whole, to detect issues quickly and proactively respond to them.

Together, monitoring and observability are critical to ensuring the availability and performance of a microservices system, as well as allowing development and operations teams to better understand system behavior and identify areas for improvement.

Microservice: DevOps and Automation #6

Israel-Lopes — Tue, 25 Apr 2023 17:25:27 +0000

DevOps is an approach that emphasizes collaboration and communication between development and operations teams to ensure faster and more reliable software delivery. This is done through process automation, continuous integration, continuous delivery and continuous system monitoring. In microservices architecture, DevOps is essential to ensure that services are delivered quickly and with high quality.

Automation is another important approach in microservices architecture, which aims to reduce manual workload and increase efficiency by automating repetitive tasks. This includes automating testing, deployment, configuration management, and system monitoring. Automation is essential to handle the scalability and complexity of services in a microservices environment.

Together, DevOps and Automation are critical to the success of microservices architecture. They allow development and operations teams to work together more collaboratively and efficiently, reducing errors and increasing productivity. In addition, they allow services to be delivered more quickly and reliably, ensuring customer satisfaction and the company's competitiveness.

The main idea of DevOps is to establish a culture of collaboration among these teams, so that they can work together more efficiently and productively, towards a common goal: to deliver high quality software faster and more reliably.

For this, the DevOps approach seeks to automate development and operations processes, including testing, deployments, monitoring and infrastructure management, allowing teams to focus more on strategic aspects of the project.

DevOps also emphasizes the use of agile practices such as continuous integration (CI), continuous delivery (CD), test automation, configuration management, among others.

The DevOps approach is critical in modern development environments, including microservices architecture, as it allows teams to work more collaboratively and efficiently, delivering software faster, more securely, and more reliably.

___________<< back______________next page >>__________

How to kill unwanted ssh processes

Israel-Lopes — Tue, 25 Apr 2023 17:22:00 +0000

This command will list all connections established with the sshd process. Write down the port number of the process corresponding to the rogue connection and the ID of the process running on that port.

sudo netstat -tnpa | grep 'ESTABLISHED.*sshd'

You can then use the ps command to check the processes running on the system and find the PID corresponding to the port you identified. For example:

sudo ps aux | grep sshd

This will list all running processes related to sshd. Write down the PID of the process running the port you identified.

Finally, run the kill command with the PID of the process you want to kill:

sudo kill <PID>

If you use creativity, you can close http, ftp, telnet and other processes.