
<figure className="reset">
  <video
    autobuffer
    loop
    type="video/mp4"
    playsInline
    controls
    className="full-width"
  >
    <source
      src="https://padilla-media.s3.amazonaws.com/blog/video/TubelordNightofThePencilsCompressed.mov"
      type="video/mp4"
    />
  </video>
</figure>

[Listen on Youtube](https://youtu.be/lnszmkkNDWU)

Didn't think I could pick that fast!!

[Thanks to Let's Talk About Math Rock](https://www.youtube.com/watch?app=desktop&v=oRQfvEXj_gc&ab_channel=Let%27sTalkAboutMathRock) for the tabs and curated licks.


Tubelord - Night of The Pencils


![🫚](https://padilla-media.s3.amazonaws.com/blog/art/sketches-2025-06-14.jpg)

Been eating lots of these guys!


Beet Peek


![🌅](https://padilla-media.s3.amazonaws.com/blog/art/sketches-2024-06-15.jpg)

🌄


Sunset Flight


There are great benefits to be had when bundling an application in a Docker Image. Namely, maintaining control over the environment, including runtime versions, package managers, and environment variables. From a development standpoint, developing with docker can ensure all those same benefits on your local machine, instilling confidence that there won't be any unforeseen errors due to a difference in build environment.

So! Today I'll dive into how you can take your docker image and throw it up on AWS for deployment.

## Services

We'll be looking at using two services: Elastic Container Services (ECR) and Elastic Container Registry (ECR)

**ECS** is the platform which will actually enable us to setup the hosting environment for our application. When configured with AWS **Fargate**, much of the nitty gritty of instantiating separate services is taken care of. 

**ECR** is the AWS proprietary image repository for hosting your docker image on build. ECS will reference our specified repo to find the image to build our app from. ECR stores images based on versions, or **tags** as they're called. You can set a tag by version number or any other unique identifier, and then rollback if you ever need to.

## Setting Up the AWS Services

To setup ECR and ECS, I'll recommend logging into to the AWS console and setting up your repo in ECR and creating a Service and Task in ECS. The sensible defaults should be ok with getting you started. [Official AWS tutorials](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_AWSCLI_Fargate.html) may be helpful to reference as you do so.

To keep this post brief, I'll be focusing on the CLI deployment.

## Deploying to ECR

Assuming we have a working Dockerfile and application, here's how we can get started.

We'll start with building the image locally. This can later be automated in a CI/CD process. For now, though, we'll do it through the command line:

```bash
$ docker build --no-cache -f myapp.Dockerfile -t <AWS_ACCOUNT_ID>.dkr.ecr.<AWS_REGION>.amazonaws.com/<ECR_REPO_NAME>:<TAG> .
```

Be sure to run this from your project directory, or change the `.` to refer to the root of your project.

Biggest thing to note here is that we're tagging our image with the `-t` flag. The tag we are giving it should match with all of the AWS specific variables provided above.

Once that's done, we'll log in and retrieve AWS permissions to push our image in the following step:

```bash
$ aws ecr get-login-password --region <region> | docker login --username AWS --password-stdin <AWS_ACCOUNT_ID>.dkr.ecr.<AWS_REGION>.amazonaws.com
```
Be sure that you have in your env variables the appropriate AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY. Those will override any variables set in your aws command line profiles.

From there, we're set to push the image!

```bash
$ docker push <AWS_ACCOUNT_ID>.dkr.ecr.<AWS_REGION>.amazonaws.com/<ECR_REPO_NAME>:<TAG>
```

## Running Your ECS Task

You can run your task from the AWS portal, though while we're here, we may as well fire it up from the command line!

```bash
$ aws ecs run-task \
  --cluster <CLUSTER_NAME> \
  --launch-type FARGATE \
  --task-definition <TASK_DEF> \
  --network-configuration "awsvpcConfiguration={subnets=[<subnet-id>],securityGroups=[<security-group-id>],assignPublicIp=ENABLED}"
```

Swapping all of your appropriate variables here will enable you to spin up the application, now deploying to a subnet of your choice and soon running on AWS!


Deploying a Docker Image to AWS Elastic Container Service


![🔵](https://padilla-media.s3.amazonaws.com/albums/covers/jam-3d.jpg)

Collectathon Island's magical power-orbs have been scattered all over the place! We need a lovable 3D anthropomorphic mascot to use their signature jumping and running abilities to return them all.

Inspired by Richard Jacques, David Wise, and countless summers playing platformers.

Purchase on [🤘 Bandcamp](https://letsgochris.bandcamp.com/album/jam-3d) and Listen on [🙉 Spotify](https://open.spotify.com/album/293UUHqalwPdaIIrDzlD0C) or any of your favorite streaming services!


New Album — Jam 3D 🟢


Guitar has hands down been the hardest instrument I've played as far as getting familiar with the notes.

Saxophone, admittedly, is one of the easiest. You really only have to learn 20 different finger combinations, and then you know most of the instrument.

Piano is even easier!! You learn 12 notes and you can apply that to all 88 keys. _Maybe_ you could say it's more like 24, since you're also reading bass clef.

Here's the thing about those instruments: They are two dimensional. You play up the piano, and gradually go up. Same with sax and most wind instruments.

Guitar, though, is three dimensional. You can go up the instrument by following a string up _or_ by hopping to another string.

**Wicked.**

If you're like me, you can go surprisingly far on guitar without knowing too many notes, too. A trained ear and know that a scale is a series of whole and half steps does wonders.

But! It doesn't take me far enough. So here's how I'm going about actually learning where every single note is on this instrument:

## 1. Reading Sheet Music over tabs.

For bettor or worse, I learned to read music from the page.

If you're learning and you don't already read music, I'm not sure it's that necessary depending on what you want to do. If you already do, making the notes visual is a pretty great first step

## 2. Barre Chords

A two for one: Once you can play barre chords, there's no better way to get familiar with the thickest two strings than with playing this across the instrument.

## 3. Hardcore Memorization

The least sexy, but the most effective. A professor of mine from undergrad, while learning Portuguese, said it plainly: "There's a lot of romanticizing around immersive learning. While that's all fine and well, nothing beats buying a dictionary and memorizing the words."

The point isn't one is better than the other, you need both, but guitar players (especially me) can be guilty of only playing and putting off learning the notes through a more rote approach.

Thankfully, it's infinitely easier in 2023 with apps and online tools.

At the risk of this blog sounding like a sponsored post: My favorite is [Justin Guitar's Note Finder App](https://www.justinguitar.com/store/note-trainer). It's what you'd expect and a little more: Finding the note on a nice GUI, an option to try and identify what note is being shown. It even feels like a game, so it can be addictive to study the neck this way.

## 4. Triads

My next step is moving on to playing triads to bridge the theory to actual music making. More improv on it coming soon. 😁


Learning the Neck on Guitar


I'm doing the 250 box challenge right now. It's the namesake for the website [drawabox.com](https://drawabox.com/).

The gist: You draw lots of boxes in 3 point perspective. In pen. And you extend your lines at the end to check that the points converge towards a vanishing point.

_**Brutal.**_

The exercise looks like this:

![📦](https://padilla-media.s3.amazonaws.com/blog/art/250boxesandrepetition.jpg)

The point is to get familiar with perspective. And every now and then I stop and ask "am I doing this wrong? Are there any tips? Am I just not looking at it the wrong way. Maybe if I find another guide..." It's a question I've had for most art. If I find the right strategy, I'll just know how to do the thing.

But, in my experience so far, there is just some intuition that comes from repetition. There's no real strategy aside from "do it again, but try another approach."

On a practical level, what helps me is to plot a dot for where I think a line will go and then ghost it like crazy. I'll intentionally plot one that I know is parallel as a reference if I'm really unsure.

But, for the most part, it's like learning a sport or an instrument: the more you do it, the more your brain will learn the fine-motor control of what you're trying to do.

That's what really struck me! Just like I have to practice scales, I have to warm up on drawing lines.

I kind of wish the challenge was called "Draw 250 boxes (mostly badly!)" since that's the intention behind it!

All this to say: Art, especially at the beginning, is just as much a physical skill as it is a design skill.


Chris Padilla/Blog

On This Day