Forem: Cristian Paul Peñaranda Rojas

Computers are

Cristian Paul Peñaranda Rojas — Sat, 10 Jan 2026 21:25:28 +0000

Technology, Time, and Information

Technology isn’t anything but a reflection of the human inability to do some things.

Time is usually the limit—and also the path—but I meant it as a barrier, without technology we could not do things that would usually take us time and energy, from sending an email to sending a short message.

Of course, there are situations where sending a message in person changes everything. It also reduces the chances of deception, but it replaces a poor bandwidth—one that these days isn’t enough for our bodies to be satisfied, catching up with every movement our body makes to communicate.

So technology, again, involves many means: from actual building blocks, guns, books, instruments, and calculators—by which I mean computers.

I may be naïve to think that computers were created at all in constrast counting and mathematics were concepts that took a lot of time for humanity to develop. They also take a lot of our brain capacity, so we had to develop signs, tools, and eventually computers to perform these operations faster. This is information, nonetheless. Computers then became the solution—hence, the tool—to process and transport information in a non-natural way, because humans tend to modify the environment to their desires. Information, at least today, is how we interpret the world around us, which is made of the same things—but that’s a topic for other books.

The Beginning

Computers don’t seem to grow by themselves—at least not yet—so they are tools we build. They come with two main components: the CPU and the memory. Although the CPU also contains a small amount of memory inside it, additional dedicated resources that are needed to remember and store information. That’s why memory is so important, and basically, it’s what everything is about anyway.

Time also plays an important role in how a CPU functions. Without time—and specifically without clock crystals—CPUs wouldn’t be able to function, to run, or to perform operations. That’s the basis of what a CPU does: it moves information all the time, basically doing math and logic. This is probably logic we already perform in the world, but at a simpler and more fundamental level—not as advanced as controlling traffic, though that’s a good analogy.

We’re trying to be fundamental here. Computers figure out the most repetitive operations our minds perform and convert them into machinery and tools that harvest memory (computer memory), so programs can exist. These programs are compilations of instructions, which is (again) information—but different from a book that is meant to be read (at least in principle). These words (programs) are actually able to modify and/or create information (more words).

All of this happens at speeds that seem to be limited only by physical constants, like the speed of light—how fast information can travel and how fast it can be accessed. Since this is a classification exercise in a way, the more information you put in the same place, the harder it becomes to access it due to physical limitations. It’s good to note that bridges suffer from related problems due usage but don’t fall down because they are big, and maintenance can be performed—or they are eventually replaced.

With computers and their bridges, we’re crossing limits of the things we can’t see with the human eye. All of this is happening in spaces so small that even more constraints and unknowns appear. Yet here is humanity, trying to build CPUs and memory smaller every day so we can keep piling information into the so-called cloud—which is just a bunch of computers living in the same place, connected by wires that transport light and electricity, dealing with information through programs.

These programs are written by humans—for now—but they may eventually help humans write faster and think more, which is what we want, I think, anyway.

So What Are We Doing With Computers These Days?

I’m afraid to say: almost anything.

Humanity has been able to build and continue physically building larger and larger structures—houses, bridges (again), ships, cars, rockets—and, well, humanoid-like structures called robots. These can lift boxes and dance, shadowing their creators’ movements, and eventually becoming more aware of their surroundings. Maybe one day we’ll beat nature and create humans made of different machinery—but this isn’t a novel, so that’s for another kind of book.

What’s next from here? Well, it’s up to you, I think. Computers are becoming more popular every day, and that comes with the cost of not even knowing what they are—or what they exist for—like reading this text.

IPv6 on AWS - Flat network connection between my local computer lab and the cloud

Cristian Paul Peñaranda Rojas — Tue, 26 Oct 2021 02:46:34 +0000

I like playing and building on the AWS cloud, but also enjoy developing and prototyping on my local lab full mostly of Raspberry Pi + other embedded devices.

From time to time I managed to follow a common pattern. Deploying a load balancer either in AWS or from my public IPv4 address as a way to expose to the world my applications and also communicate back and forth between the cloud and my local network.

I always keep in mind that the internet was designed as a flat data network, delivering a multitude of protocols and services between equal peers [1].

One of the benefits of IPv6 is not having NAT, this simplifies the current client server model inherit from IPv4 and gives back peer to peer communication which is something I appreciated and use in my local network, and now I can also do against the AWS Cloud.

This is my setup:

I started by creating a IPv6 tunnel (since my ISP still doesn't provide IPv6 addresses), I signed up with https://tunnelbroker.net/

And created a tunnel against their closest tunnel server:

I also assigned a /48 prefix to the tunnel, this is important for the next steps as I'll not just get the tunnel working on a single server but also routing and assigning ipv6 addresses to my Linux devices lab.

Getting tunnel setup is simple as copying their instructions for my OS.

(note that local address it's replaced from your public IPv4 address to the local IPv4 of your system)

In order to get IPv6 address from my routed prefixes (the /48 one) have to install radvd and configure it as follows:

*After that, everything is set up on my network which is now IPv6 ready.*

Now is time to create a network in AWS Cloud, for this I'll use the following Typescript code snippet so that AWS CDK will create a VPC with 3 public subnets. This a really good abstraction and time saver:

import * as cdk from '@aws-cdk/core';
import * as ec2 from '@aws-cdk/aws-ec2';


export class NetStack extends cdk.Stack {
  constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // The code that defines your stack goes here
    const vpc = new ec2.Vpc(this, 'VPC', {
       subnetConfiguration: [
          {
            cidrMask: 24,
            name: 'public',
            subnetType: ec2.SubnetType.PUBLIC,
          }
       ]
    });  }
}

IPv6 support in CDK is not ready, so I'll enable IPv6 in my VPC and subnets using the AWS CLI as follows:

Requesting IPv6 CIDR:

Get the VPC ID first

aws cloudformation describe-stack-resources --stack-name YourNamedStack --region us-east-2 | grep -oP "vpc-\w+"

Then request IPv6 CIDR

aws ec2 associate-vpc-cidr-block --vpc-id vpc-00000000000000000 --amazon-provided-ipv6-cidr-block

And save the IPv6 /56 block, this is needed next.

aws ec2 describe-vpcs --vpc-id vpc-00000000000000000 --region us-east-2 | grep "Ipv6CidrBlock"

The /56 block is split in smaller /64 prefixes, then we assigned two of them to our subnets.

We'll need to get the subnets IDs first:

aws cloudformation describe-stack-resources --stack-name NetStack --region us-east-2 | grep -oP "subnet-\w+"

Then assign two IPv6 /64 blocks to our previous listed subnets.

aws ec2 associate-subnet-cidr-block --subnet-id subnet-00000000000000000 --ipv6-cidr-block 2600:1f16:dd9:e100::/64 
aws ec2 associate-subnet-cidr-block --subnet-id subnet-00000000000000001 --ipv6-cidr-block 2600:1f16:dd9:e101::/64

Enable IPv6 automatic addressing (very important for later)

aws ec2 modify-subnet-attribute --subnet-id subnet-00000000000000000 --assign-ipv6-address-on-creation
aws ec2 modify-subnet-attribute --subnet-id subnet-00000000000000001 --assign-ipv6-address-on-creation

Routing is also necessary and our last step before start using IPv6 on an instance

Once again, we just need resources ID, this time route tables and internet gateway:

aws cloudformation describe-stack-resources --stack-name NetStack --region us-east-2 | grep -oP "rtb-\w+"

Internet gateway is important when modifying the route tables.

aws cloudformation describe-stack-resources --stack-name NetStack --region us-east-2 | grep -oP "igw-\w+"

And then adding IPv6 default route (::/0) to reach the internet.

aws ec2 create-route --route-table-id rtb-00000000000000000 --destination-ipv6-cidr-block ::/0 --gateway-id igw-00000000000000000
aws ec2 create-route --route-table-id rtb-00000000000000001 --destination-ipv6-cidr-block ::/0 --gateway-id igw-00000000000000000

Now, if I launch an ec2 instance either from the console or with the following snippet:

aws ec2 run-instances --image-id ami-08e6b682a466887dd --count 1 --instance-type t4g.micro  --iam-instance-profile Name=AWSCloud9SSMInstanceProfile  --subnet-id subnet-00000000000000000

Get a session against it, I can validate that it actually got a IPv6 address.

If I run netcat on either side of my network (cloud and local), I can communicate between both servers as if they were in the same network, in some way they are now :D.

Now I can communicate with my AWS really easily, and I'm also on my way to transition to IPv6.

It's important to *modify Security Groups* to allow connections from my /48 IPv6 network segment, or the whole IPv6 internet if you want to just host some web applications there too with AAAA records ;-)

I'm planning to use this setup to play with ECS Anywhere soon.

There are some considerations to keep in mind:

Latency is around 200ms, I might be due to my physical location.
Security Groups needs to be adjusted on the instance that run in AWS side
Review your local IPv6 router firewall as well for security reasons
Use TLS all the times, this is not a VPN.
I'm using my pi-hole box to host the tunnel and provide IPv4 to IPv6 routing on my local lab.

I hope you enjoy reading this.

[1] http://luca.ntop.org/n2n.pdf

AWS CDK - Coding a Virtual Machine in the Cloud

Cristian Paul Peñaranda Rojas — Mon, 26 Oct 2020 03:11:42 +0000

I started following AWS CDK (Cloud Development Kit) news and documentation for a while now. That's usually my lazy strategy when a new AWS product is launched, I finally decided that I wanted to start using it and create something that I'm familiar with and also find useful.

One of my favourites AWS products is EC2, for multiple reason:

Compute is Universal, it have the potential to make many things with a server running Linux.
EC2 Administration in AWS can be much more elastic, there are some additions from AWS System Manager that I enjoy using:
- No more SSH!, AWS SSM provides Session Manager instead that is Web Console, CLI and API friendly.
- Parameter Store is handy for keeping configuration values in a safe place outside the instance.
User data for provisioning, because some bash script with a few commands always gets the job done.
Elastic IPs (also knows as Public IP), probably the most simple way to connect your application to the internet!
Amazon Linux 2, one less thing to worry about because AWS maintains a Redhat/Centos like distribution.
All the goodies of EBS and snapshots.
Spot Instances, because running your servers could be really affordable if your service is smart enough to handle interruptions.

So, I decided to deploy a single instance from Python code using CDK with all the AWS cool stuff to easy the management in around 60 lines of code.

This is a snippet of what you're going to find, instance creation:

        instance = ec2.Instance(self, "Instance",
            instance_type=ec2.InstanceType("t3.nano"),
            machine_image=amzn_Linux,
            vpc = vpc,
            role = role
            )

One common issue when using user data to install software is that eventually it hits a limit, CDK Assets allows me to invoke that script from a separate file and also handles the assets management in S3 for us.

        asset = Asset(self, "Asset", path=os.path.join(dirname, "configure.sh"))
        local_path = instance.user_data.add_s3_download_command(
            bucket=asset.bucket,
            bucket_key=asset.s3_object_key
        )

        instance.user_data.add_execute_file_command(
            file_path=local_path
            )

This is the full code example for getting that instance up and running:

EC2 Instance Code Example

I hope this gives you an idea of how powerful CDK in terms of describing infrastructure and the amount of time that saves if you where using the Python SDK or Cloudformation previously.