<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Tyler Auerbeck on Medium]]></title>
        <description><![CDATA[Stories by Tyler Auerbeck on Medium]]></description>
        <link>https://medium.com/@tylerauerbeck?source=rss-eef929f68635------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*99oS7eNLx8gKwCKDdH1fWA.jpeg</url>
            <title>Stories by Tyler Auerbeck on Medium</title>
            <link>https://medium.com/@tylerauerbeck?source=rss-eef929f68635------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 00:30:47 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@tylerauerbeck/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[DevTips: Attaching VinD (Vcluster In Docker) to an existing docker network]]></title>
            <link>https://medium.com/@tylerauerbeck/devtips-attaching-vind-vcluster-in-docker-to-an-existing-docker-network-ad91e8a097ed?source=rss-eef929f68635------2</link>
            <guid isPermaLink="false">https://medium.com/p/ad91e8a097ed</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[vcluster]]></category>
            <dc:creator><![CDATA[Tyler Auerbeck]]></dc:creator>
            <pubDate>Sat, 28 Feb 2026 17:46:37 GMT</pubDate>
            <atom:updated>2026-02-28T17:46:37.512Z</atom:updated>
            <content:encoded><![CDATA[<h4>a config is a config, unless it’s the wrong config</h4><figure><img alt="Two similar configuration files pointing at each other in the theme of the spiderman pointing meme" src="https://cdn-images-1.medium.com/max/1024/1*fD6Dp50lQKfanGQMP_5Qng.png" /><figcaption>A config only helps when it’s in the right place</figcaption></figure><p>After a while of hand mangling some initial local development environments to fit my needs, I’ve decided to start looking at some new tooling to help me make this a bit more streamlined. Like most folks who want to spend 0 dollars to work on half baked ideas, I’ve relied heavily on old faitherul, KinD, to get some clusters setup. But once I dig into an idea, that generally ends up with me veering pretty far from the standard config.yaml and needing to dig into further configurations or toss together some other form of automation to get all the things I need deployed.</p><p>More recently, I’ve been playing around with Vcluster, more specifically the VinD tooling/config to see if this gives me what I’m looking for. Still early days here, but I imagine I’ll write some words about the experience once I put this through some more thorough testing. But one thing I’ve run into (as with most tools) is the overloaded wording of config.</p><p>You see, in my development environment. I kind of want all the things I’m spinning up to be able to talk to each other. From my local machine, to (maybe) multiple clusters, to other standalone docker containers. And I’m not talking just hard coding some docker IPs. I want to be able to have name resolution, certificate handling. All the usual goodies.</p><p>So for me, being able to get all these things on a reachable network together is good. So when I first started digging into how/where to configure joining new vind clusters to an existing docker network. I thought this would be fairly straightforward. The problem was that my feeble mind read the documentation and interpreted “add this to your config” and assumed that everything is talking about the same config.</p><h4>Problem One: Specifying Docker Networks</h4><p>The first task of course was tracking down how to specify the docker network that I wanted my clusters to get created in. Conveniently, vcluster has some <a href="https://www.vcluster.com/docs/vcluster/configure/vcluster-yaml/">docs</a> which point you in the right direction. Specifically for vind, you’ll be interested in the configurations available under experimental.docker . From there, we can see that we can add the following to attach to our network of choice:</p><pre>experimental:<br>  docker:<br>    network: &lt;your-network-here&gt;      </pre><p>The only call out here is to make sure when you search for vcluster docs in your search engine of choice, that you make sure to pick the docs for the latest stable release of vcluster (0.32 at the time of writing). My initial problem was that google was sending me to some old documentation which didn’t contain the experimental.docker docs and I had to dig a bit further to find what I was looking for.</p><h4>Actual Problem: What Config Are We Talking About</h4><p>So finding out what to put in the config file was actually the easy part of this problem. My stumble actually showed up about how to apply that config. You see, when I just did a quick vcluster create --help I quickly saw the following and assumed config meant config:</p><pre>vcluster create --help<br>&lt;snip/&gt;<br>Global Flags:<br>      --config string       The vcluster CLI config to use (will be created if it does not exist) (default &quot;/Users/tylerauerbeck/.vcluster/config.json&quot;)</pre><p>I saw the --config flag and (clearly) immediately stopped reading. Upon further inspection, it does call out vcluster <strong>CLI </strong>config<strong> . </strong>But I clearly interpreted that as “<strong><em>gimme all your configs</em></strong>”. So whenever I dumped our above snippet into a config.yaml and tried to create a cluster with vcluster create &lt;cluster-name&gt; --driver docker --config config.yaml , I see something that resembles:</p><pre>vc create medium --driver docker --config config.yaml<br>12:15:45 info Ensuring environment for vCluster medium...<br>12:15:46 done Created network vcluster.medium<br>12:15:51 warn Failed to run command docker &lt;snip/&gt;</pre><p>So we can see that it clearly told me to get lost because it’s creating its own network and ignoring my preferences. But with also the added benefit of breaking everything else! Why is everything broken? Well because I unknowingly gave it a faulty vcluster <strong>CLI</strong> config, which now leaves it unable to create it’s primary task of creating a cluster, with the added annoyance of making me feel like it’s ignoring me and telling me that it’s going to create its own network anyway.</p><p>So with a little poking and prodding, I discovered the -f flag (representing values)</p><pre>vcluster create --help<br>&lt;snip/&gt;<br>  -f, --values stringArray                Path where to load extra helm values from</pre><p>Here is where I realized that --config is only actually configuring the <strong>CLI</strong>, which was what was causing the cluster creation to blow up. To actually pass in the configuration for our <strong>CLUSTER</strong> — I needed to pass in the cluster configuration values. Apparently under the covers there is some helm’ing happening which is one of the things that threw me off. Since I was specifying a docker config (and running this in docker), I had assumed this would have been pre-cluster configuration that needed to happen. But, live and learn.</p><h4>Solution</h4><p>So with all of this knew knowledge in place — our command now looks something like this:</p><pre>vcluster create medium --driver docker -f config.yaml<br>12:30:56 info Ensuring environment for vCluster medium...<br>12:31:01 info Starting vCluster standalone medium<br>12:31:02 done Successfully created virtual cluster medium<br>12:31:02 info Finding docker container vcluster.cp.medium...<br>12:31:02 info Waiting for vCluster kubeconfig to be available...<br>12:31:04 info Waiting for vCluster to become ready...<br>12:31:13 done vCluster is ready<br>12:31:13 done Switched active kube context to vcluster-docker_medium<br>- Use `vcluster disconnect` to return to your previous kube context<br>- Use `kubectl get namespaces` to access the vcluster</pre><p>And now we’re ready to get rolling! As you can see, our message about creating its own network is gone. And we can actually see the cluster get created.</p><p>If nothing else, this can serve as a reminder to myself next time I run into this problem. But hopefully this helps to smooth out any sharp edges for anybody else running into the same problem.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ad91e8a097ed" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Meta-Medium: I wanted to write, so I built something to help me figure out where to write]]></title>
            <link>https://medium.com/@tylerauerbeck/meta-medium-i-wanted-to-write-so-i-built-something-to-help-me-figure-out-where-to-write-de2e40626d53?source=rss-eef929f68635------2</link>
            <guid isPermaLink="false">https://medium.com/p/de2e40626d53</guid>
            <category><![CDATA[medium-publications]]></category>
            <category><![CDATA[writing]]></category>
            <category><![CDATA[publication]]></category>
            <category><![CDATA[publications-on-medium]]></category>
            <category><![CDATA[medium]]></category>
            <dc:creator><![CDATA[Tyler Auerbeck]]></dc:creator>
            <pubDate>Thu, 19 Feb 2026 02:45:30 GMT</pubDate>
            <atom:updated>2026-02-19T02:48:14.915Z</atom:updated>
            <content:encoded><![CDATA[<h4>Building An Easier Way To Find Publications</h4><p>Well, as with most other nonsense that I find myself involved in. I started with an idea I wanted to write about. And then I immediately found myself a new side-quest.</p><p>You see, writing your own blogs on Medium is fine. But getting involved with a publication does tend to get some additional eyes on your writing. Which is great! But which one!? How do I know which publications correspond to my niche topic? How do I find who to talk to, how to submit, etc.</p><p>Well according to the best searches and queries I provided to our search and AI overlords — apparently the current best hope is some lucky keyword searching on the Medium website AND this <a href="https://medium.com/@MediumStaff/list/7c0ec8037e61">curated list</a> by the <a href="https://medium.com/u/a32c340ea342">Medium Staff</a> . The curated list is great. However, it’s just a big ol’ list. You can’t search it by name. You can’t search it by topic. And it’s definitely not a living or complete list as you’ll see by all the comments in the thread.</p><p>It just feels like we can do better.</p><p>So here is my submission that absolutely nobody asked for.</p><h4>The Requirements</h4><ul><li>I wanted to be able to see a comprehensive list of publications</li><li>I wanted to be able to search them by name</li><li>I wanted to be able to search them by keyword</li><li>And maybe sometime I’d also like to search them by editor</li></ul><h4>The Problem</h4><ul><li>Well, we can’t fix all the problems. We still don’t have a great way to populate this with up to date information. It will still require someone updating the list. Just like the curated list from the Medium staff, there will need to be some mechanism for submitting a publication information to be added to the list. And because it’s the internet, you want that to be validated by _something_ before it just gets added.</li></ul><p>Well, you can’t win them all. But you can start to make it better. So ignoring that fact that this list will still need to be opt-in, we can at least make interacting with it a bit better.</p><h4>The Answer</h4><p>And because I can’t pass up the chance to buy a domain, now we’ve got <a href="http://mediumpubs.com/">mediumbpubs.com</a></p><p>The most important piece of the site to call out can be seen below:</p><figure><img alt="A banner showing that this side project is not sponsored or affiliated with Medium.com" src="https://cdn-images-1.medium.com/max/614/1*2xCv832VIEnoj7lyZhAE-w.png" /><figcaption>In no way, shape or form it this affiliated with Medium.com</figcaption></figure><p>This was just a fun side project to solve a problem that I was seeing. In the end, I hope it helps others.</p><p>When you first land on the site, you’ll see a little description of of the problem space that first made me want to put this together in the first place. From there, there are really two components that users will interact with: the submission form and the catalog.</p><h4>Submit Your Publication!</h4><p>Well, without a list of publications this would be rather pointless. And as I mentioned, this will still need to be opt-in for now. There are no real requirements outside of:</p><ul><li>Does this seem real?</li><li>Is this not empty?</li><li>Are there real editors?</li></ul><p>This project isn’t here to be an arbiter of “the best publications”. But it does hope to be free of garbage. We’ll see how that evolves if/when this becomes useful to folks. But for now, this is the front door to get into the catalog.</p><p>For the submission itself, we’re really looking to populate just a handful of fields for now:</p><ul><li>The name of your publication</li><li>A link to the publication itself</li><li>A contact email for the publication</li><li>An optional logo/icon for the publication</li><li>Links to one or more of the editors for the publication</li><li>Any related keywords that you’d like to relate to the publication</li></ul><p><strong>The Publication Catalog</strong></p><p>Once a submisison has been reviewed and merged in, it will then be searchable in the catalog. Once populated with real data, it might look something like this</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TB9dT-ANs6me9GDvifR0WQ.png" /></figure><p>From there, you’ll see the available publications that we currently know about and we can start doing some searching over them. We can search by name, by contact and even editor. More interestingly, you can click on any set of the keywords and you’ll begin to filter the above list.</p><h4>Build It And They Will (Hopefully) Come</h4><p>Again, this was more just to scratch an itch. But to be clear, it is alive! You can visit <a href="http://mediumpubs.com/">mediumpubs.com</a> right now to see the site. But for it to be useful, it needs you! It needs the information about these publications to be useful. Yes, I could definitely just scrape those lists and threads that exist. But that feels a little gross to me. I want things to appear here because folks want to be included. So we’ll let this populate organically.</p><p>So tell me, which publications do you love the most? Let’s get them added to the list! Is there additional information you’d like to be able to search on? Let’s hear it in the comments.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=de2e40626d53" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Notes From The Homelab: Configuring A Local Docker CLI To Work With Remote Podman]]></title>
            <link>https://medium.com/@tylerauerbeck/notes-from-the-homelab-configuring-a-local-docker-cli-to-work-with-remote-podman-4cbf3354e009?source=rss-eef929f68635------2</link>
            <guid isPermaLink="false">https://medium.com/p/4cbf3354e009</guid>
            <category><![CDATA[homelab]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[podman]]></category>
            <dc:creator><![CDATA[Tyler Auerbeck]]></dc:creator>
            <pubDate>Wed, 09 Jul 2025 21:31:43 GMT</pubDate>
            <atom:updated>2025-07-09T21:31:43.302Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a4oh7wfo4jOoAS8jxThvRA.jpeg" /><figcaption>Sometimes you’ve just gotta get Docker and Podman to coexist on all of your machines.</figcaption></figure><p>With the school year activities winding down and brief lull before I kick off a number of house activities, I of course decided it was about time to sit down and clean up all of these computers I’ve got haphazardly laying around into some sensical shape that I can call a <strong>homelab</strong> (re: I stuffed them all in a rack and plugged them in). So at this point, I’ve got a bunch of Kubernetes clusters, two Macs that I use on a daily basis and a beefy Fedora Silverblue dev machine where I can jettison a bunch of builds, random utility containers, etc. to.</p><p>This is about the point where I realized the docker commands that I’ve <em>regrown</em> accustomed to running started to bite me. As Fedora naturally comes installed and functional with Podman, I didn’t want to have to go through the obstacle of installing Docker there, but I also didn’t want to change my existing workflow and install something like Podman Desktop on my local machines.</p><p><em>And this is where you’ll all tell me about why I should just use Podman for all the things. And that’s fine. But you don’t need to cite the dark magic to me here friends. I was there. I know the benefits. It’s just in the ways and places that I work now.. these are the ways that I can remain a functional member of the team. If you are without these constraints, I am very happy to hear that.</em></p><p>But for those of us who are happy to dance this jig, there are times where we may find ourselves living in both worlds. We may just want our docker CLI to work with all the backends — whether they’re Docker or not. Specifically if I’m using the Docker CLI and I’ve got a machine somewhere on the backend that’s actually just got podman available. It makes things simple. Ideally as little additional configuration/installation as possible was my goal as I was going through this.</p><p>As someone who has actually done this enough times now that it should be burned into my memory — I was actually surprised to see that the garbled mess that is Google AI Summary didn’t just pop up the steps needed here and even a brief skim of the search results didn’t lay this out directly. So I figured maybe I would scream something out into the ether so that something useful could pop up next time I find myself needing to do this.</p><h4>Setting Up Your Docker Context</h4><p>So as I’m driving a lot of this from either of the Mac’s that I’m working from on a daily basis — I’ll need to get my Docker CLI talking to the other backends — which themselves are either Docker or Podman. We’re going to focus specifically on Podman here though. To do this, we’ll set up a different Docker context, which tells us that we’re going to be talking to Docker in some other space. In this case, it will be Podman running on my separate machine.</p><p>To do this, we can run:</p><pre>docker context create silverblue --docker &quot;host=ssh://me@silverblue&quot;</pre><p>Now what this does is allow me to specify using a context that will interact with my remote machine running podman. It does this by telling it to go run some docker commands against the remote host we specified via SSH.</p><p><strong>Note: </strong><em>If you’re not already setup to be able to connect to your remote machine via ssh, you can set this up with the following (where you replace me and silverblue with your own username and hostname respectively).</em></p><pre>ssh-copy-id me@silverblue</pre><p>Once our context is setup, we can then run docker context use silverblue to tell docker to start running all the commands I specify against this specific host/context.</p><p>So of course, when I went to run something like docker ps I expected it to just work! Of course, I was wrong:</p><pre>error during connect: Get &quot;http://docker.example.com/v1.44/containers/json&quot;: <br>command [ssh -o ConnectTimeout=30 -l me -- silverblue docker system <br>dial-stdio] has exited with exit status 127, please make sure the URL is valid,<br>and Docker 18.09 or later is installed on the remote host: stderr=bash: <br>line 1: docker: command not found</pre><p>While the above is a whole lot of words, the last handful actually tell us what’s going on. On the remote host, the docker command isn’t there. Naturally, because of course it’s not. It’s a podman machine. Why would it have a docker CLI present?</p><h4>Configuring Our Podman Host</h4><p>Alright. So that’s the issue. In order to test the remote connection, Docker on the local machine expects there to be a Docker CLI on the remote machine. For this case, there exists the podman-docker package. It’s available in most distributions, so you can install it using the standard installation methods. For Fedora/Fedora Silverblue, that looks something like:</p><p>Fedora:</p><pre>sudo dnf install -y podman-docker</pre><p>Fedora Silverblue:</p><pre>rpm-ostree install -y podman-docker </pre><p>Once this is installed, what you have is basically an alias setup so that whenever something calls docker, it actually calls podman. So anything expecting to be able to use a Dmocker command will be able to work as expected. So now this should work right! RIGHT!?</p><pre>&gt; docker ps<br>Cannot connect to the Docker daemon at http://docker.example.com. <br>Is the docker daemon running?</pre><p>Of course there’s still more to do. One of the big differences between Docker and Podman is that Docker expects there to be a socket that it can connect to. However since we’re trying to connect over to a Podman host — there’s nothing there to connect to. So our Docker CLI is confused and just thinks that the service must not be started. To give Docker something to hook into we can enable the podman.socket service. Well that’s simple enough, so the first thing that you’ll probably want to do is run</p><pre>sudo systemctl enable --now podman.socket</pre><p>And of course, we would be wrong. I can tell you this because that’s exactly what I did and I was still seeing the same error about the docker daemon running that we saw above. And why is that? Well because I started that service with sudo, which means it’s running as root. And, unless we set up our context to connect as root, that will not be available to us. So if we want this socket to be available specifically to the user that we set up our Docker context to use, then we’ll want to run this (as that specific user) on your remote host:</p><pre>systemctl --user enable --now podman.socket</pre><p>At this point, the socket will be online and then we can finally test this by running the following from our local host (in my case one of the Mac’s):</p><pre>&gt; docker ps<br>CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES</pre><p>I of course don’t have anything running because we’ve just set this up. But we have a connection now! And now all of my machines can work together happily without me having to think about what commands I need to run.</p><p>Hopefully this is helpful! But if nothing else, hopefully this helps out future me next time I need to re-do this again!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4cbf3354e009" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Using Cloudflare For Your Custom Bluesky Domains]]></title>
            <link>https://medium.com/@tylerauerbeck/using-cloudflare-for-your-custom-bluesky-domains-82ed9fee8da0?source=rss-eef929f68635------2</link>
            <guid isPermaLink="false">https://medium.com/p/82ed9fee8da0</guid>
            <category><![CDATA[blue-sky]]></category>
            <category><![CDATA[cloudflare]]></category>
            <category><![CDATA[dns]]></category>
            <dc:creator><![CDATA[Tyler Auerbeck]]></dc:creator>
            <pubDate>Fri, 10 Jan 2025 17:02:14 GMT</pubDate>
            <atom:updated>2025-01-10T17:02:14.573Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="A robotic butterfly sitting on a cloud connected to cables" src="https://cdn-images-1.medium.com/max/512/1*W2_4napAsSG53Cvl8aSSVQ.png" /></figure><p>Over the holiday break(s) — I had sat down and converted my Bluesky handle from the very nice <a href="https://bsky.app/profile/tylerauerbeck.bsky.social"><strong>tylerauerbeck.bsky.social</strong></a> to use one of the many, many domains I had laying around. Since Bluesky has made this simple, it almost doesn’t make sense to write this up — just follow the directions on their site!</p><p>However, I decided to take a few extra steps.</p><p>In general, you probably have a domain (i.e. awesomehandle.io ). Once you decide you want to start using that as your handle, it’s as simple as navigating to Settings -&gt; Account</p><figure><img alt="The Bluesky settings prompt" src="https://cdn-images-1.medium.com/max/914/1*S4UlZXGrFgEKcuYxxcukQg.png" /></figure><p>Once there, you’ll se an option to adjust your Handle</p><figure><img alt="The handle suboption of the Bluesky account settings menu" src="https://cdn-images-1.medium.com/max/1024/1*jy9L2rm9K4XaQVnTvfyqHA.png" /></figure><p>Now you can provide your handle awesomehandle.io and it’ll provide you with the instructions for creating the appropriate DNS records.</p><figure><img alt="The Bluesky change handle menu" src="https://cdn-images-1.medium.com/max/1024/1*nVAVPzpLDYQJBT0msIBQBQ.png" /></figure><h3>Off To Cloudflare We Go</h3><p>With the above information, we can head over to Cloudflare to begin setting up our DNS records. If you don’t already have a Cloudflare account, you can go ahead and sign up for a free account <a href="https://www.cloudflare.com/plans/">here</a>.</p><p>At this point, we’ve made some assumptions that we already own the domain that we want to work with. If that’s the case, go ahead and skip to the next section. However if that’s not the case, then what you want to do is get logged into your account and choose the Register Domains option from under the Domain Registration menu item on the left hand side of your screen</p><figure><img alt="The Cloudflare Domain Registration menu" src="https://cdn-images-1.medium.com/max/482/1*74GxNVJz-1_OCiAJTIwcJQ.png" /></figure><p>From there, you’ll be able to search for whatever domain you’re interested in and purchase it if it’s available. From there, you can enter all your payment information and that ✨shiny new domain✨ will be all yours.</p><figure><img alt="Cloudflare Register Domain Screen" src="https://cdn-images-1.medium.com/max/1024/1*TN1H72VKa07mytFK4PJtMA.png" /></figure><h4>Time For DNS</h4><p>Now that we officially have our domain, we can go ahead and set up the appropriate DNS records so that Bluesky will start using it as our handle. To do this, from your accounts home screen you’ll want to choose the domain that you want to work with. In my case, I used auerbeck.xyz (which you’ll see in the following examples instead of our imaginary awesomehandle.io example domain we were using above.</p><figure><img alt="Cloudflare Domain Overview Screen" src="https://cdn-images-1.medium.com/max/1024/1*6BNmreHoTttIUfLz4xpPQA.png" /></figure><p>Once you click your domain, you’ll land on the overview page for that domain. On the left hand side of the screen, you’ll see a menu item for DNS with a Records option underneath that you can choose to begin crafting your records.</p><figure><img alt="Cloudflare Domain DNS Management Menu" src="https://cdn-images-1.medium.com/max/498/1*QkOWI3hzRCitzOpjVk5PFg.png" /></figure><p>Once you click through, you’ll see the option to Add Record and then you can choose TXT from the dropdown (as that’s the type of record that Bluesky will be looking for. Based on the inputs that the prior Bluesky prompt had given us, we would create a record that looks like this.</p><figure><img alt="Cloudflare DNS Record Wizard" src="https://cdn-images-1.medium.com/max/1024/1*HzcohqGOYdqZvN-yyTiHGA.png" /></figure><p>Once you verify that the above looks correct, you can click the Save button below your prompts and your record will be live! Once the record is saved, we can navigate back to our Bluesky screen and click Verify DNS Record . If all is configured as expected, then this will succeed and your new handle will be live!</p><p>But what about your old handle? Well more recently, you have nothing to worry about! Part of the process of switching to a custom domain now also reserves your previous handle (i.e. <strong>tylerauerbeck.bsky.social).</strong> However, when I had done this a month or so ago, this wasn’t quite ready. So if you <a href="https://bsky.app/profile/tylerauerbeck.bsky.social">check here</a> , you’ll see that I just reregistered my old handle and left a pointer post to come find me at my new handle.</p><p>But really, that’s it. That’s all there is. You have your new handle. Go forth and post your heart away.</p><h4>But Wait, There’s More!</h4><p>Now if all your want to do is use the root domain as your handle. You’re done. Go do the thing I just said!</p><p>But if you’re like me and were already hosting something at the root of your domain (in my case <strong>auerbeck.xyz), </strong>then this is going to be a problem. You can’t have two things using the same DNS record! So what I wanted to do was make my handle a subdomain: <strong>tyler.auerbeck.xyz</strong>. Which really is no different than what we just did, just a few extra keystrokes in the right places. If we navigate back to create our DNS record, we would just make the following changes:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S8yXHXc9d1X1OTfixFnoQg.png" /></figure><p>You’ll notice that the record looks very familiar. However all I did was at the subdomain prefix to _atproto in order to create the expected DNS record. Once you’re satisfied with the record, go ahead and click save and follow the same steps that we did previously to verify our DNS record. Once that succeeds, we’re back in good shape! You’ll know have a handle at a subdomain with your existing domain.</p><h4>Becoming Easy To Find</h4><p>At this point, we’ve got our custom domain in whatever shape we decided we want it. However if you’re slapping your handle around on the internet, people may do something silly like click on it. Without some additional DNS legwork, this will be a problem. Initially, your handle isn’t actually routable. What this means is that if someone were to try to hit <strong>tyler.auerbeck.xyz</strong> , you would just get something similar to <strong>Page Not Found</strong>. However, Bluesky provides a way for us to setup a redirect which will route that link to the Bluesky site and then lookup your actual profile. To do this, we’ll create one more DNS record.</p><p>This time, we’ll select CNAME from the record type dropdown. If you went the subdomain route, you’ll use just the subdomain as the name. However, if your handle is just the root of your domain, you can leave it empty. Most importantly, we’ll set the target as <strong>redirect.bsky.app</strong>. This will be the magic that routes the domain to Bluesky for lookup. Make sure that you uncheck the Proxy button and set this to DNS only and click save.</p><figure><img alt="Creating the Bsky redirect record" src="https://cdn-images-1.medium.com/max/1024/1*Io-Uz_eCx2CocLXPG2yeOg.png" /></figure><p>Once you click save, you may want to give it a minute or so for everything to propagate, but from that point forward you could actually drop navigate to your Bluesky handle in your browser and it will take you directly to your Bluesky profile.</p><h3>Custom Domain Benefits</h3><p>So with all of that done, is it really worth the effort to configure a custom domain? I personally believe so. Using a custom domain begins to provide at least a base layer of verification that this account is indeed you (rather than the more generic bsky.social , which anyone could register).</p><p>Additionally, once you begin to establish yourself using this identity, you want to make sure it’s easy to find you there. So being able to use this custom domain and ensuring that traffic gets routed where a user may expect it goes a long way (vs. something with Twitter where folks just needed to know how to take @username wherever they happened to find it and then look it up on the bird site).</p><p>Regardless, I hope this makes the idea of having to work with DNS to get your desired handle on Bluesky a little more approachable. There are plenty of things that can go wrong when poking at DNS — sometimes they’ll be your fault, and other times it’ll be internet weather. But with the above instructions you should be able to start cruising Bluesky with the domain of your dreams ✨.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=82ed9fee8da0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[VSCode Starter Pack: Getting Started with Python For Data Science]]></title>
            <link>https://medium.com/@tylerauerbeck/vscode-starter-pack-getting-started-with-python-for-data-science-0512a73b33fb?source=rss-eef929f68635------2</link>
            <guid isPermaLink="false">https://medium.com/p/0512a73b33fb</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[vscode]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[learning]]></category>
            <dc:creator><![CDATA[Tyler Auerbeck]]></dc:creator>
            <pubDate>Wed, 30 Oct 2024 20:42:08 GMT</pubDate>
            <atom:updated>2024-10-30T20:42:08.466Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gpn1uQtdeG1-AAwYCUIWqQ.jpeg" /></figure><p>Occasionally, I find myself teaching some courses on a number of topics. Most recently, I’ve been teaching a course around getting started with Python and Data Science concepts.</p><blockquote>Wait. Didn’t you say that already? We get it. You teach classes.</blockquote><p>Yeah, I know. I said that before. But then my brain got real hyped about ways of teaching and took me in a <a href="https://medium.com/@tylerauerbeck/more-apprentices-less-parrots-teaching-how-to-think-vs-how-to-work-5d1983445ba4">different direction</a>. But we’re back! And now we’re gonna talk about what I actually meant to write the first time</p><blockquote>And what’s that?</blockquote><p>Well, setting up a nice starter environment for a Python Data Science class of course! I’ve taught classes like these in a few different places and in a few different ways and it’s always bothered me a little bit that it’s done in a way and generally with tooling that I’ve just never seen or heard of before.</p><h3>Why Teach What We Don’t Use?</h3><p>Listen, I get it. We’ve got a lot to cover. We just want to make things easy. We will just give you a ready baked environment to get started in and we’re off the the races. Which is probably okay. They can focus on the topics at hand. But that’s good until either the next course OR even worse, their first job. How are they going to know how to get started on their next project without actually having to set it up themselves?!</p><p>I don’t know about you, but speaking for myself, a developers tooling is fine tuned to the developer themselves. We may show someone how to get started, but that environment eventually becomes a reflection of that persons brain and their way of thinking. With enough time and practice, it’s an extension of their brain itself.</p><p>So that’s why I believe in introducing students of all experience levels to tools that they’re actually going to see. Let them get used to and familiar with them now. Make sure they know how to navigate with them, make sure they know how to discover and navigate the community and documentation and most importantly, make sure they know how to make it their own.</p><h4>Easy Bake Oven, But For Code And Data</h4><p>Now this isn’t to say it’s best to just toss everyone into the deep end (although sometimes it is; an exception for every rule). My thinking here though is give them the baseplate. Give folks the basic ingredients and let the kids cook, as they say.</p><p>So for this particular example, what we’ll get started with is VSCode. I’m not going to be here to argue about what’s best, the value of some other IDE or why I’m not forcing anyone into starting out in VIM. What I’m here to do is to show that you can (and should) get started with a well known IDE and get it set up in a way that shows you how to actually accomplish the goal you want to complete.</p><h4>Our Goal:</h4><p>Have a basic environment where we can begin completing Python based data science exercises, focusing initially on primarily on Pandas.</p><p>So let’s get started</p><h4>Installing VSCode</h4><p>This first bit is about as plain as it gets. We need the tool. So let’s go get the tool. You can pick up the installer VSCode for your platform <a href="https://code.visualstudio.com/download">here</a>. This is a standard installer, so just launch it and follow the standard instructions to get it installed. Once you’ve got it installed, you can launch VSCode and you’ll have a regular, degular install that looks like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4aC-HKC0knj42z8XS2Marg.png" /><figcaption>A very empty, freshly installed VSCode installation</figcaption></figure><p>My install will reflect a MacOS setup, but for the most part after the install everything should be the same regardless of the platform you’re running on.</p><h4>The Plugins</h4><p>That being said, a normal install of VSCode is kind of like buying a thing, and then just leaving it in the box. You know it can do so many things! But you’re just leaving all of that untapped potential sitting there, not serving you. <strong>A waste. </strong>So let’s make sure we don’t make that mistake.</p><p>Plugins can be the key to unlocking a ton of velocity in VSCode. And the nice (but sometimes very sharp) bit of this is that it mostly comes at the click of the button. There are times when installing a plugin can reduce a ton of overhead in your developer workflow. That being said, because of the ease of installation, it can also lead you down a deep dark hole of plugin FOMO, which inevitably results in the bloat of your IDE. <strong>So buyer, beware</strong>. Start with what you need and build from there!</p><p>In our case, let’s remind ourselves of our goal:</p><ul><li>Python Environment</li><li>Data Science Starter Kit</li></ul><p>So to begin we’ll find ourselves the following plugins:</p><ul><li>Python</li><li>Pylance</li><li>Python Debugger</li></ul><p>This will give us the Python environment that we’re desiring. A majority of the other tooling that we’re interested will be handled via Python itself, but one particular set of plugins will be helpful to us as we start some of the DS work. Specifically, we’ll want the following Jupyter plugins:</p><ul><li>Jupyter</li><li>Jupyter Keymap</li><li>Jupyter Slideshow</li><li>Jupyter Cell Tags</li><li>Jupyter Notebook Renderers</li></ul><p>To grab all of these we will want to navigate to the plugins tab of our VSCode window and we can search for them by name:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/339/1*gPXui7JCTVZOgxUyZa-vjQ.png" /><figcaption>Tracking down our Python plugins</figcaption></figure><p>On the left hand side of your window, you’ll see the little building blocks icon which is where you’ll find your plugins. From there, you can see a search bar where you can type in the name of all of the above plugins that I’ve mentioned. You’ll see the install button and you can go ahead and click on them to begin the installation. Once it’s finished, you may (or may not) be prompted to restart VScode. If you see no restart prompt, you’re good to go!</p><h3>We Have The Technology</h3><p>Alright, we’ve got the tools and presumably we’ve got the time. So what better time to get started than now! However, this is really just the beginning. Before we can write any code, we still need the packages that will unlock all of our data science needs. To do this, we’ll use a few different tools.</p><h4>Virtual Environments</h4><p>The first, and maybe most important, is configuring a virtual environment. Why do we want a virtual environment. To save yourselves the pain of forever fumbling between dependencies and potentially causing yourself a ton of grief by interfering with your local system packages. I’ve experienced no greater pain than having one project that works, going to work on another and then coming back to my previously perfect project and finding out, nothing works and the house is on fire because suddenly none of my packages know how to work together any longer.</p><p>This is exactly what a virtual environment is for. While this of course can be done directly from the command line, since we’re talking about VSCode we’re going to focus just on how to do this through the UI.</p><p>The first thing we need to do is get ourselves some space to begin working. We’ll use VSCode to create a new directory to begin creating our python files in. After you’ve launched VSCode, you can just click the Open prompt and it will pull up your file explorer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/571/1*xx2QwLdn6H7lwtb3Uy8wgA.png" /><figcaption>Creating a space to work in VSCode</figcaption></figure><p>From here, you can go ahead and click the New Folder option (or otherwise navigate to somewhere you would like to create a new folder at) and create a directory of your choosing. For our purposes, we’ll name ours starter-pack . Once the directory has been created, go ahead and click on it and then click Open .</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/794/1*exnYEcFhmnaN8JAD4aGhvA.png" /><figcaption>Creating a directory in VSCode</figcaption></figure><p>From here, you’ll see your folder appear in the file explorer in VSCode (that’s the icon that looks like multiple pages folded over each other). The directory is empty for now as we’ve just created it, but let’s go ahead and solve that problem.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/314/1*OOlCiT8yGEQZXPJ2-URWNA.png" /><figcaption>Our empty directory in the VSCode file explorer</figcaption></figure><p>We’ll go ahead and click on the New File icon, which is the first icon next to the name of our directory. You should see your cursor start flashing and you’ll be able to type a filename of your choosing. For our purposes, let’s start with main.py . We’ve go ourselves a directory to work in and we’ve stubbed out an example file. <strong>WE’RE ALMOST THERE!</strong></p><p>At this point, we’re ready to get our virtual environment up and running. This is where our plugins will begin to come in handy. Once a plugin is installed it can come bundled with any number of pre-set actions. In the case of our Python plugin, it provides a set of actions to allow you to set up a virtual environment. The way that we gain access to these actions is through the Command Pallete . You can find this under the View menu, alongside the keyboard shortcut you can use to automatically pop it up. However you decide to access it, once it pops up, we can begin typing Python: Create Environment and you’ll begin to see the action that we want to launch. Once we see that, go ahead and click on it to begin.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/596/1*8zb8DRO8tiGNWCbKOo3BaQ.png" /><figcaption>Creating a Python virtual environment</figcaption></figure><p>Once launched, you’ll have two options. You can create a virtual environment with venv OR you can create an environment with conda . What you’ll find is this will really come down to your preference. For our purposes, I’ll stick with venv because it’s what I know. Go ahead and click venv and you’ll then be prompted to choose a Python interpreter. Depending on the number of versions installed on your system, you may have a number to choose from. It’s generally safest to go with the latest to ensure you’re developing with an up to date version of Python. However, if there’s a specific version of Python that you need to target, feel free to proceed with that one as well.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/592/1*EHU6nF5BnN1scQXrZp05og.png" /><figcaption>Selecting venv as our preferred virtual environment</figcaption></figure><p>After we’ve got that sorted, you should see a small loading bar at the bottom right hand of your editor. But more importantly, we should see a .venv folder pop into existence in our file explorer. We don’t have to worry too much about the specifics of what’s in this folder — but just know that VSCode has activated this virtual environment for you and Python is now using the contents of this directory. It includes the binaries that you’ll be referencing (`python`,`pip`, etc.) and any of the packages that you will go on to install.</p><p>One additional step (although unnecessary, but I highly recommend) is updating your settings to automatically activate your virtual environment when you launch a terminal. This can be done by navigating to Settings . Once this screen pops up, you can begin typing python.terminal in and a number of settings should rise to the top. The ones that we’re interested in is Python &gt; Terminal: Activate Env In Current Terminal and Python &gt; Terminal: Activate Environment . In my experience, without these checked you can sometimes find yourself attempting to do something and then realize that your environment actually hasn’t been activated. With these checked, it should take care of this for you. You may need to restart your editor after making these changes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1Vjolz3LprZJoO-TLIoFDg.png" /><figcaption>Configuring venv activation by default in the Settings menu</figcaption></figure><p><strong>Note: </strong>If you ever find yourself having to manually activate your environment, it’s not a big deal. You can just run source .venv/bin/activate and you should be in good shape.</p><h4>Packages? What Packages?</h4><p>Ah, yes. Those pesky packages that we actually need to begin doing our work. What we have at the moment is just a clean environment to begin doing our work in and the promise of not blowing up our laptops. We’re not even at the point of having the tools we need for the job yet! But now we can begin to solve that. The first time we go to set this up, we’ll be doing some additional leg work to get this all set up. To do this, we’ll need to drop into a terminal.</p><p><strong>Note: </strong><em>It’s going to be okay. I promise. If you’re not familiar with the terminal, it can’t hurt you. We’re going to just start with some basic </em><em>pip commands to get what we need. We can make sure you two become friends another time.</em></p><p>We’ll first start by launching our terminal. Again, you can find this under the menu Terminal and choose New Terminal . You should also see the shortcut to launch this a bit quicker in the future. You also could use the Command Palette like we did earlier. You’ll find there are usually many ways to do the same thing and you’ll slowly find the way that you’re most comfortable working. Do what works for you!</p><p>With our terminal now open, let’s install some packages. As a reminder, the second part of our goal here is to build out a data science toolkit that will allow us to quickly jump into a number of DS exercises. So the packages we’ll jumpstart our project(s) with will be used for that purpose.</p><p>With that said, the packages we’ll be interested in are:</p><ul><li>pandas</li><li>seaborn</li><li>numpy</li><li>requests</li><li>matplotlib</li></ul><p><strong>Note: </strong>This should not be considered an exhaustive list. Again, <strong>starter pack.</strong> This will give us just enough to get started with some initial exercises. What you’ll find as you begin to do more and more is that you’ll find that either a) some of this doesn’t fit your needs or b) it does and actually you want to add more to it. That’s great! <strong>Keep what works. Toss the rest! </strong>This is most importantly an exercise in building out a toolbox that <em>could</em> work for you. What you fill it with will be completely up to you!</p><p>With that rant complete, let’s go ahead and get these packages installed. We’ve got our terminal open, we’ve got our list of packages. Now all we need to do is feed them to pip and we’ll get these installed. We can do this all at the same time with:</p><pre>pip install pandas seaborn numpy requests matplotlib</pre><p>You’ll then see a bunch of text pass you by telling you that all of these packages have been installed. You’ll notice we didn’t pass in any particular version. At this point, we’ve done that on purpose. We want the latest. However, there will be a time when you want to make sure that you continue to build to certain tooling.</p><p>To make sure we’ve got a list of what exactly it is we pulled down, we can actually use pip to generate ourselves an inventory so that future us can take this same code, in a new environment, and end right back up in the same place as we are today. To do this, we can run:</p><pre>pip freeze &gt; requirements.txt</pre><p>If we take a small sample out of that file, we’ll see something like:</p><pre>requests==2.32.3<br>seaborn==0.13.2</pre><p>We can see that it tells us the exact version of the package that has been installed. We could then use therequirements.txt in any other environment (or even the same environment if we trash and recreate our virtual environment) to recreate everything without running those individual pip install commands. We could instead run the following (with our generated file) and get the same result:</p><pre>pip install -r requirements.txt</pre><p>And just like that, we now know how to setup a space to start developing in and cobble together the tools we need to get started. We also have the ability now to recreate that same environment over and over again should we like to. Almost like it would be cool to use it as a template for any future projects or exercises we might want to get into.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/220/1*5C5EFgjGi03rnVhTrNwKdA.gif" /><figcaption>Ah, a template. This was the plan all along.</figcaption></figure><h4>GitHub Template</h4><p>And this brings us to the nice, bright pink bow we can slap on all of this. The worst part of any project tends to be getting started. You’ll sit there and think to yourself:</p><blockquote>I do this. Every time. Why can’t I just click a button and deal with all of this scaffolding?!</blockquote><p>Well, as it turns out, you can. You could keep things simple and just do the ol’ copy paste from this directory into a new directory each time. But.. that’s kind of gross and only works from your local machine. What if instead we made this a template that could be accessed from anywhere that we could grab it from GitHub?</p><p>I’ll save the lecture on the importance of source control for another time. But that aside, being able to get a fresh copy of your template with a few taps of the keyboard can save a ton of time. All we need to do is create a repository in GitHub and commit our main.py and requirements.txt files. We’ll save ourselves the pain of the terminal for the moment and look at this via the UI.</p><p>Assuming that we already have a GitHub account and are logged in, we can visit <a href="https://github.com/new">https://github.com/new</a> to create a new repository. For our purposes, we’ll call this example-starter-pack , but you can call it whatever you would like. Click Add a README file as well and then click Create Repository .</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/802/1*OntblmeNbPOuQXmvFi6OTw.png" /><figcaption>Creating a new repository in GitHub</figcaption></figure><p>Once we’ve got our empty repository, it should drop you on a screen that looks like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/919/1*wIw7OEWOJFKNRnMUaamuiA.png" /><figcaption>A GitHub repository with an empty README</figcaption></figure><p>Now all we need to do is add the two files we mentioned above main.py and requirements.txt . So now all we need to do is click the Add file button that we see above and choose either Add file or Upload files . Since main.py is just going to be an empty file, we can just click `Add file` , give it the title of main.py and click Commit changes . Since we’re setting this up as our own template repo, it’s okay to merge directly to main . We can talk about the peril of committing to main another day ❤.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1REg_KQx6_ciSa7GNyV5tA.png" /></figure><p>At this point, we’ll have something that looks like the following:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EdrXSfu29vCM6OhBKH3Rog.png" /><figcaption>Our GitHub repository with our empty main.py file</figcaption></figure><p>So now our final piece will be adding the requirements.txt file. Since this is just a handful of lines, let’s go ahead and copy those from VSCode to our clipboard (a little copy pasta never hurt anybody). Once we’ve copied those contents, let’s go ahead and add another file just like we did for main.py . This time we’ll be configuring the name of the file AND pasting the contents into that file.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YeK6mgowkwOHMQ41wtWv4Q.png" /><figcaption>Adding our inventory of python packages to our repository</figcaption></figure><p>With that completed, we’ll commit this file just like we did the last one and we’ll end up with all the contents that we need. You might be asking:</p><blockquote>But what about our .venv folder ?!</blockquote><p>While that’s important on the machine and during the time you’re working in your virtual environment, once you’re done with it you don’t need it at all! You especially don’t want/need to be committing that into source control as you’ll just be lugging a number of binaries and other packages along that you don’t actually need.</p><p>But now that we’ve got our repository in the shape that we want, there’s one last step in making it a fully fledged template directory. As it stands, you could just keep cloning this repository, making changes, and then committing it to some other repo. But again, we have better tools to make your developer workflow fly!</p><p>What we’ll want to do is click on Settings at the top of our GitHub screen</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/917/1*arLaeC75A9i84Cj9xvIfQg.png" /><figcaption>Finding the Settings tab in GitHub</figcaption></figure><p>Once we’ve clicked through this menu, we should a button that says Template repository right under our repository name. Go ahead and click that. Once you click it, it will immediately make this repository a template repository!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/815/1*iszlRiiwVuWsrYRF9veUdA.png" /></figure><p>If we navigate back to the root of our repository, you’ll notice a new button that says Use this template . If you go to click on that button, you’ll see that you have the option to Create a new repository which will return you to the repo creation screen that we saw before. This will look almost identical to how we created ours manually previously, except that it nows shows that we’re using our template. It’ll ask us where we want to put it and then we can choose to create a repository as normal from there.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*57sj56GL8Az2fBCMnxNETw.png" /></figure><p>Just like that! No more copy and pasting all over the place. Anytime we want to jump into a new project, we can bust out our newly built toolkit and get right to business.</p><h3>The End</h3><p>If you’ve made it this far, you’re probably saying to yourself.</p><blockquote>That was a lot of work. And a whole lot of words.</blockquote><p>And I completely agree. But like with most things, a little investment up front will save you a whole lot of time in the long run. At this point, we now know how to get our VSCode environment up and running, ensure that we keep our work confined to just the location we want it to and then set up a toolkit which we can then use repeatedly anytime we want to dive into a new project.</p><p>Are there better ways? Almost definitely. Are there better tools? I’m sure you’ll continue to refine that as you dig deeper into more complex projects. But for folks just getting started or joining a new team, I’ve found this to be a nice way to remove complexity to allow them to focus on the task(s) at hand and provide them a jumping off point to begin filling out their own toolboxes. My approach has changed over time and I’m sure will continue to change over time and I hope that if you take anything away from this, it’s that yours should too! As I mentioned earlier: keep what works, toss everything else. And then keep doing that, repeatedly.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0512a73b33fb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[More Apprentices, Less Parrots: The Importance Of Teaching How To Think vs How To Work]]></title>
            <link>https://medium.com/@tylerauerbeck/more-apprentices-less-parrots-teaching-how-to-think-vs-how-to-work-5d1983445ba4?source=rss-eef929f68635------2</link>
            <guid isPermaLink="false">https://medium.com/p/5d1983445ba4</guid>
            <category><![CDATA[apprenticeship]]></category>
            <category><![CDATA[learning]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[teaching]]></category>
            <dc:creator><![CDATA[Tyler Auerbeck]]></dc:creator>
            <pubDate>Wed, 23 Oct 2024 20:42:39 GMT</pubDate>
            <atom:updated>2024-10-23T20:45:44.194Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cldxJIuYDau0mZTyKr3cTQ.jpeg" /></figure><p>Occasionally, I find myself teaching some courses on a number of topics. Most recently, I’ve been teaching a course around getting started with Python and Data Science concepts.</p><p>I personally love teaching these introductory style courses. Working with folks who are just getting started in the field can be invigorating and helps me realize a ton of the things I take for granted as someone who has been doing this for longer than I care to think about now.</p><p>But, for some reason, in a number of tutorials and places I’ve been to, we seem to underestimate the audience that we’re working with. We show them how to learn in tools that I’ve never once come across in the real world. We focus on showing them how to do things perfectly instead of considering the problem and considering approaches to take to solve the problem. All of this likely in the absence of how to surface documentation, assess the value of an example or learning how to engage with the community they will find themselves working in.</p><p>This, I believe, is detrimental to learners in a number of ways. The most obvious being that they’re going to go need to learn something new once they find some of their first opportunities in the real world. While learning how to work within a specific tool is a key skill, being able to learn about how to learn to use a tool or decide whether that is the tool for the problem is equally as important.</p><p>This last piece is something that I believe should be focused on by the teacher/writer just as much as it should be for the learner. While we all may have our best laid plans about what we’re going to show our students, inevitably there will be a question about how to do something that we either don’t know or haven’t planned for. <strong>THAT’S PERFECT</strong>. Show them how to do the thing. Even better if you don’t know, walk through how you go about figuring out how to do the thing. One of two things will happen.</p><p>You will either:</p><ul><li>figure out how to do the thing; <strong>PERFECT</strong>, student learns how to do the thing</li><li>not figure out how to do the thing; <strong>EQUALLY AS PERFECT</strong>; student learns how to investigate how to do a thing; the places to search, the places to ask questions; how to deal with temporary defeat while trying to accomplish something</li></ul><p>These are all equally beneficial to a new learner. These are things that they will inevitably need to know how to deal with. I think failure is an equally good teacher, especially early in the career, because it starts to build the idea that just because something didn’t work, doesn’t necessarily mean it was bad or a waste of time. The amount of time I’ve had to spend coaching junior engineers out of feeling like an imposter or being nervous to admit that they can’t do something is astounding. I’ve found that once you’ve done enough to coach them out of that shell, it can almost be like working with a different person.</p><h3><strong>SO WHY ARE WE NOT TEACHING THIS FROM THE START!?</strong></h3><p>Well, in writing, having to pull all of this together can be difficult. Our attention span these days is <em>not great</em>. By the time we get through the setup, we’ve probably lost 90% of readers. But, if we just hand wave to get to the exciting bit, we keep folks captured and ensure they read what we actually wanted them to. Likewise with teaching, you sometimes have to choose your battles. Is it more important to hit the notes that you want? Do you need to figure out you cover all of the specific content within a given timeline? Sure. But that burden is on us. What we need to remember is that we have a responsibility to the folks who have come to us to learn and to show them the skills they’ll need to be successful moving forward, whether they’re viewed as soft skills or not.</p><h3>What’s The Fix?</h3><p>Unfortunately, there’s no silver bullet or one way of writing/teaching that is going to solve this problem. But what I would encourage you to do is think out loud when writing or teaching. There is nothing someone early in their career is going to benefit from more than seeing how someone who has been doing this for some time thinks about a problem. They’ll be able to borrow from and build on ways that you wrestle with a problem. They’ll start learning where to go and who to talk to when you don’t have answers. <strong>Don’t be afraid to fail spectacularly!</strong> Talk through what you did, how it apparently didn’t work and more importantly what you do next to go find the right answer! Find folks to bring in and talk about their horror stories. Everybody can learn something from burning rubble. It’s how we learn not to set the next dumpster on fire!</p><p>In summary: build things, watch them blow up, tell everybody what you learned and how you got there. There’s still nothing wrong with unloading a half-baked idea onto the internet or ensuring that you hit specific topics that you need to throughout a course. But building the next generation of critical thinkers and problem solvers is going to be crucial. Otherwise we may find ourselves with barely functional software and nobody to figure out how to make it better.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5d1983445ba4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Plight Of The VolumeClaimTemplate: How To Update Your PVC Once It’s Been Created By A Managed…]]></title>
            <link>https://medium.com/@tylerauerbeck/plight-of-the-volumeclaimtemplate-how-to-update-your-pvc-once-its-been-created-by-a-managed-9f5886feeb93?source=rss-eef929f68635------2</link>
            <guid isPermaLink="false">https://medium.com/p/9f5886feeb93</guid>
            <category><![CDATA[stateful-applications]]></category>
            <category><![CDATA[statefulsets]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[persistent-volume-claim]]></category>
            <dc:creator><![CDATA[Tyler Auerbeck]]></dc:creator>
            <pubDate>Wed, 16 Oct 2024 16:01:37 GMT</pubDate>
            <atom:updated>2024-10-16T16:01:37.115Z</atom:updated>
            <content:encoded><![CDATA[<h3>Plight Of The VolumeClaimTemplate: How To Update Your PVC Once It’s Been Created By A Managed Resource</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aNzf_veqHdFcCGuvHhAwNg.jpeg" /><figcaption>Live photo of me, each time I find a StatefulSet and the associated VolumeClaimTemplate not matching the actual PersistentVolumeClaim</figcaption></figure><p>Recently, I’ve been reminded of an old enemy of mine. The VolumeClaimTemplate. Now you might say to yourself, it’s YAML. It can’t hurt you. Well, that may be true. But it certainly was enough to stress eat a whole box of girl scout cookies whiled I pleaded with the universe that I wasn’t going to accidentally unravel the database that was in charge of something fairly important: making all the money.</p><p><strong>Gather ‘round. Let me tell you a story.</strong></p><p>There once was a tiny lil’ StatefulSet. And it ran a fairly important database. For you see, people did the things, those things were kept track of , and then this particular database allowed us to collect dollar bills for those things. Without this database, we were not able to keep track of the things and thus, no dollar bills for us.</p><p>So, whenever maintenance needed to happen, you wanted it to be real, real fast. So that you know, it didn’t impact the tracking of the things, etc., etc.</p><p><strong>Enter: The On-call Engineers</strong></p><p>Well, lucky for us, things were going well. Many a thing was happening. Dollars bills were flowing all around. This was great! As you can imagine, everyone was walking around high-fiving, the money was flowing. Life was good.</p><p>Except for the cranky on-call engineers. You see.. things were going a little .. too well. The things were being collected and stored, but at a very high rate. So we (yes, I am one of those cranky on-call engineers), would get woken up. Oh, you’re running out of storage? AGAIN!? Well, after more nights than we all probably cared to admit, it was time to do something about this.</p><p>Luckily for us, a nice little project called <a href="https://github.com/topolvm/pvc-autoresizer">pvc-autoresizer </a>already existed. I love it when a project already exists! We didn’t even really have to do anything, just deploy the resizer, apply some annotations, and success. The PVC’s would get resized per the configuration we supply.</p><p><em>Oh.</em></p><p><em>We have to.. apply annotations.</em></p><p><em>To the PVC.</em></p><p><em>That is managed by a StatefulSet.</em></p><p><strong>Hello everyone. Welcome. Let me introduce you to the villain of our story.</strong></p><p>And why is that? Well that is because once an object like a StatefulSet creates a VolumeClaimTemplate, it doesn’t really let you touch it via the StatefulSet again.</p><p>The promise of the VolumeClaimTemplate is great. It allows you to describe the storage you want as part of your initial workload without actually having to manage the PVC itself. This is generally fine if you have a very well defined deployment and understand its storage needs almost completely. However, should you ever find yourself in a spot where you need to modify this at all, you’ll quickly run into a problem. You see, none of the fields under the VolumeClaimTemplate are fields that you are able to modify once a StatefulSet has been created. Need to resize your storage? <strong>Not happening. </strong>Just need to slap some labels or annotations on this thing?<strong>Don’t even think about it.</strong></p><pre># statefulsets.apps &quot;web&quot; was not valid:<br># * spec: Forbidden: updates to statefulset spec for fields other than &#39;replicas&#39;, &#39;ordinals&#39;, &#39;template&#39;, &#39;updateStrategy&#39;, &#39;persistentVolumeClaimRetentionPolicy&#39; and &#39;minReadySeconds&#39; are forbidden<br>#</pre><p>Now, this isn’t to say that there isn’t a way to get the deed done. To accomplish the things you need to do, you can directly patch the managed PVC.</p><pre>kubectl patch pvc very-fake-pvc \ <br>  -p &#39;{&quot;metadata&quot;:{&quot;annotations&quot;: { &quot;hello&quot;: &quot;world&quot;}}}&#39;</pre><p>Anything you need to add, just patch it directly into the PVC and you’re in great shape. But doesn’t that kind of defeat the purpose? If anything, it almost feels like this is worse. <strong>THIS ISN’T THE DECLARATIVE FUTURE THAT I WAS PROMISED!</strong></p><p>Following this patch method, I now have a StatefulSet that describes my storage one way, but the reality is that my storage now doesn’t reflect the thing that I originally defined. What happens if I need to go apply this workload to another cluster? What happens if some sort of disaster happens to our cluster and we need to redeploy this workload. Under fire, I certainly don’t want to have to remember:</p><blockquote>“oh yes, that patch command”.</blockquote><p>When you begin to add any GitOps tooling on top of this, it becomes immediately worse. Because at this point, you’ll forever have some object that is out of sync. You could try to sync it. But then you’ll be cursed with some red nastygram telling you what I mentioned above. These fields can’t be updated. GET LOST!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/716/1*oZMhXHmoM616PCHgbdVJtg.png" /><figcaption>Out of sync objects and red lettering as far as the eye can see</figcaption></figure><h4>Ride The Keyboard Lightning Out Of This Nightmare</h4><p>Now, there is still a way out of this mess should you ever find yourself in this situation. And let me be clear. <strong>It’s still super duper gross</strong>. You would prefer not to find yourself here. Yet, here is where we are.</p><p>The first step is what we mentioned above. Ultimately, your goal and the value you’re looking to find here is updating your PVC. So you’ll need to grab your patch command and go at it alone. The StatefulSet is not going to be here to help you. So whatever you need to patch into your PVC, you can do via this command (or if you’re feeling lazy, feel free to hop right on in viakubectl edit .</p><blockquote><strong><em>DISCLAIMER</em>: </strong>Busting out kubectl in production environments is ideally not the first tool you’re leaning into. Humans typing on keyboards are error prone in the best of situations, so make sure you know what you’re doing and double check your work.</blockquote><p>At this point, you’ll have accomplished exactly half of the job. The still more problematic bit is that you have a StatefulSet that is describing your PVC one way and reality reflecting another. As the error message that we’ve seen before clearly states: can’t touch this.</p><p>But, we have ways of making these particular Kubernetes objects sing. It again requires leaning into kubectl (<strong>read disclaimer above</strong>), but it will get the job done. This step will require us to orphan our running pods from our StatefulSet. What this does is allows the workload itself to continue running (re: NO DOWNTIME!), while allowing us to reapply the object that actually manages the workload. And when we are reapplying that object, we can make sure to update our VolumeClaimTemplate to reflect the new reality of the PVC. To do this, you’ll run the following command:</p><pre> kubectl delete statefulset &lt;statefulset-name&gt; --cascade=orphan</pre><p>Now, if you run kubectl get statefulset , you’ll notice that the StatefulSet itself is gone. However, checking to see that your pods are still running with kubectl get pods will show you that there’s nothing to fear, your application will still be humming along just as expected.</p><p>Now, let’s be clear about one thing. While we do want to update the StatefulSet YAML to reflect the reality of the situation, nothing is actually happening to the PVC after we update our StatefulSet YAML. That’s because it’s seeing that the storage already exists so it’s not going to touch it. If the PVC was missing of course, it would create it according to the definition that we’ve provided. The process we’re going through however is purely to save future on-call engineers from having to untangle the mystery of why two definitions of a PVC don’t align.</p><p>If you’re living in GitOps world, it also makes all the red go away and everything will believe it’s synced up again.</p><h4>Looking To A Better Future</h4><p>I share this story because I’ve needed to walk quite a few folks through situations like this over the past few years. There are <a href="https://github.com/kubernetes/kubernetes/issues/69041">long running issues</a> that have been open in the Kubernetes repo asking for updates for these exact issues! But, here we are in 2024, and good things may (hopefully) be coming our way soon. There have been a few KEP’s looking to address this in the past, but <a href="https://github.com/kubernetes/enhancements/issues/4650">this one</a> in particular seems to have some <a href="https://github.com/kubernetes/kubernetes/pull/126530">legs</a>.</p><p>Hopefully, this workaround will let those of us in this situation continue to run those dollar making workloads that need some additional manual intervention. But If nothing else, hopefully this saves you a few extra minutes and some unnecessary heartburn along the way while we all keep our fingers crossed for a fix to deliver us from the pain.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9f5886feeb93" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Publishing to Dev.To From Medium]]></title>
            <link>https://medium.com/@tylerauerbeck/publishing-to-dev-to-from-medium-f5808d7240f5?source=rss-eef929f68635------2</link>
            <guid isPermaLink="false">https://medium.com/p/f5808d7240f5</guid>
            <category><![CDATA[integration]]></category>
            <category><![CDATA[publishing]]></category>
            <category><![CDATA[devto]]></category>
            <category><![CDATA[medium]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Tyler Auerbeck]]></dc:creator>
            <pubDate>Tue, 08 Oct 2024 16:02:10 GMT</pubDate>
            <atom:updated>2024-10-24T23:35:24.821Z</atom:updated>
            <content:encoded><![CDATA[<h4>A Foot In Both Worlds; Meeting The Community Where They’re At</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mle58FYkw4MUihZ_hhYRWA.jpeg" /></figure><p>As I’ve recently restarted slinging words onto the internet, there were questions I needed to answer before I got back to business. After deciding to stop wasting my time agonizing over a personal site, I needed to grapple with exactly where I wanted to toss these words to. In the past, I’ve gravitated towards <a href="https://dev.to/">Dev.To</a> because that’s where all my friends were. However, I also liked the idea of Medium because I knew folks who wrote things here and the option of potentially monetizing things if I wanted to go that route in the future.</p><p>So, like any reasonable technologist, I decided I didn’t want to think about this anymore and I was going to do both. I’d use Medium as a home base and I’d also shuttle those same writings back over to Dev.</p><h4>Medium As Home Base. Why?</h4><p>Now why have I decided to write <strong>in </strong>Medium instead of <strong>to</strong> Medium? At this point, I’m still figuring out the <em>how</em> of my writing process, but at this point I’ve been bouncing between Notion and the Medium app itself. At this point, the UX of the Medium app is nice enough and allows me to just tap out some words as I’m thinking about things and then easily come back to polish them up at my computer later. So the ease of use at this point is what has drawn me to stay here instead of just publishing out to Medium as a second location.</p><h4>How.To Dev.To</h4><p>So now that I figured out where I’m initially publishing come content, I needed to figure out how I was going to get it to a second location at DEV. I initially thought I would need to dust off a very old <a href="https://github.com/tylerauerbeck/publish-to-dev.to-action">GitHub Action</a> to get this done. While I’m always up for breathing some new life into my old projects, I also didn’t want to go find out all the ways that the DEV API has probably changed since I last touched it. So I was pleasantly surprised to find out that they were going to make this much easier on me.</p><h4>Trust, Dusty RSS</h4><p>Enter the well established, very reliable RSS protocol. RSS, which stands for Really Simple Syndication, is a protocol that allows websites to publish and update content in a common format for downstream consumers to ingest.</p><p>I was pleasantly surprised to find out that both of these sites offered RSS in the direction that I needed them. Medium on the sending side offers an RSS feed of articles that you publish that others can subscribe to. One thing on the Medium side that I want to call out is just how <a href="https://help.medium.com/hc/en-us/articles/214874118-Using-RSS-feeds-of-profiles-publications-and-topics">well documented</a> and configurable it is. You can get an RSS feed in almost any shape that you that your heart desires (your whole feed, just specific tags, custom domain, etc.). It’s amazing.</p><p>For my example, it was easy.<strong> I wanted it all</strong>.</p><p>So I was able to get this by utilizing an address in the shape of https://medium.com/feed/@&lt;username&gt; . With my RSS feed in hand, I was then able to head on over to DEV to get things configured on that end.</p><h4>Configuring RSS Replication To DEV</h4><p>As I already had a DEV profile to start, I was able to get right to business. If you don’t already have one, you can head on over and go through a standard sign up process just as you would with any other site. Once you’ve got your account in hand, you can get logged in and you’ll be able to click on your account iconin the upper right hand corner of the screen. Once you click on that icon, you’ll see a dropdown and you can click on Settings.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/301/1*NY8Qr1ZfjIDee_culw6Wog.png" /><figcaption>Account Dropdown Screen</figcaption></figure><p>Once you click on Settings , you’ll be taken to your account info page. You’ll see an Extensions option in the navbar on the left side of the screen. Click on extensions and you’ll be greeted with a number options. The one we’re interested in is labeled as Publishing to DEV Community from RSS . It’ll look something like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/743/1*sX4bfZ9fjTaeWU_aYTAUDA.png" /></figure><p>There’s a few lines of information here (and you’ll notice they specifically call out how to do this from Medium, which is convenient). But what we’re most interested in is dropping the RSS feed link we’ve already pulled together. From here, there are two additional options that you might be interested in. The most important of these is Mark the RSS source as canonical URL by default .</p><p>What does that mean? What is a canonical url? Well if you do a quick search, you’ll have some folks who think it is super critical. Others will say it’s SEO nonsense that no one actually follows. But to keep things simple, according to our good friends over at <a href="https://developers.google.com/search/docs/crawling-indexing/canonicalization">Google</a>, the canonical URL is the most representative link to a piece of work on the internet. In other words, it’s the original or source of the content. So in this case, we’re marking our source article on Medium as the original source so that search engines drive traffic to the original source, while still making it available to the community we still want to be part of over on DEV.</p><p>Once we’ve got all of that plugged in, we can go ahead and click Save Feed Settings and everything will begin to get sucked into Dev. And we’re off to the races, right? RIGHT?!</p><h4>A Little Tidying Up Never Hurts</h4><p>Well, turns out we’re not quite finished yet. Setting up our RSS ingestion only brings things over to DEV as a Draft. You’ll see all of these articles in your dashboard, but you’ll still want to do a quick read through of those imported articles to make sure things like images and formatting look appropriate. While DEV does it’s best to take the content as it is from the source, there will inevitably be a few things that will need cleaned up.</p><p>What you should see for all articles that are pulled over, is something like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1UuVsyviCk-AnFG4vUqZDg.png" /></figure><p>To get things published, is not exactly self-explanatory. I was expecting to be able to click Edit and then see a big shiny red button that said Publish . However, what you’ll be greeted with instead is only a button that says Save Changes . While you may think to yourself that’s all you’ll need to do, if you click that button it’ll actually just save your changes and stay in Draft mode.</p><p>For those a bit more well versed in Markdown this might make a little more sense to you though. At the top of every imported post, you’ll see something that looks like</p><pre>---<br>title: Making Your Docker Network Reachable In MacOS<br>published: false<br>date: 2024-09-21 21:45:18 UTC<br>tags: mac,development,localdevelopment,docker<br>canonical_url: https://medium.com/@tylerauerbeck/making-your-docker-network-reachable-in-osx-e68f998f8249<br>---</pre><p>This is called frontmatterand is actually really cool to be able to see! It tells you the canonical_url that we talked about, as long as the title, date, tags, etc. that get pulled over from Medium. But the important one is published . Until you set that to true , your post will remain in Draft and only those with the direct link will be able to come see it.</p><p>That’s not what we want! So once you’re ready, flip that flag to true and click Save Changes . Once you do, your post will be live on both sites!</p><h3>Is This Worth It?</h3><p>To be honest, I have absolutely no idea. I saw that I could make two things that I like using work together, so I pressed some buttons. In the long run, I’ll be interested to compare the stats between the two sites. I figure at the least, this will help me figure out where I should direct some of my attention. Maybe there will be a time where I decide to flip between the two. On the other hand, maybe I’ll find that they’re complimentary and both have their benefits. For now, outside of the initial effort to get this set up, I don’t think it’s going to cost me much of my time to maintain, so I’ll be interested to see what it is I do learn from this. I’ll be sure to follow up with anything I do learn or any fun ways that I find to use this in the future.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f5808d7240f5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Hacktoberfest Is Coming]]></title>
            <link>https://medium.com/@tylerauerbeck/hacktoberfest-is-coming-4703602c8a42?source=rss-eef929f68635------2</link>
            <guid isPermaLink="false">https://medium.com/p/4703602c8a42</guid>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[hacktoberfest]]></category>
            <category><![CDATA[hacktoberfest2024]]></category>
            <dc:creator><![CDATA[Tyler Auerbeck]]></dc:creator>
            <pubDate>Tue, 01 Oct 2024 20:20:57 GMT</pubDate>
            <atom:updated>2024-10-01T20:20:57.553Z</atom:updated>
            <content:encoded><![CDATA[<h4>And we should all be excited (and cool, everybody be cool…)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tgfOiHFZ2Z985PHDPSWybQ.jpeg" /></figure><p>It’s October 1. And all through the repositories.. a cold shiver has (maybe) gone down the spines of maintainers everywhere. There’s a storm on the horizon. The hordes are coming. <strong>Hacktoberfest has begun</strong>.</p><p>And to be honest, that’s a real bummer to me. If I look back to my first(ish?) pull request, when and where did it come from?</p><p><strong>Hacktoberfest.</strong></p><p>So for me, this event will always hold a special place in my heart. Why? Because it’s one of those things that helped me figure out “oh, that silly little fix is important”. Prior to this, I had always just been a consumer of open source projects. I’d type away into GitHub issues and beg for help. Why? Because I was still learning how to navigate within the ecosystem. Crafting a PR was intimidating. Was my change important enough? Was it even correct? Probably not, I’m sure someone else will get to it.</p><p>But with the nudge of Hacktoberfest, it suddenly didn’t seem so scary. Was it the gamification? Was it the swag? I’m sure a bit of both had caught my interest, but suddenly I was a lot less self-conscious (and a lot more focused on filling the meter). But, looking back, the benefit here was that it encouraged me to open up pull requests. And looking back, the real value wasn’t even any of the above. It was learning how to go through the PR process. It was learning about working with upstream maintainers. And maybe even more personally, it was figuring out that not all feedback needed to hurt.</p><p>So to me, this is always how I’ll remember Hacktoberfest. As a month that has the potential to change folks lives. From that first PR, I managed to open quite a few many more. I’ve gotten new jobs off the back of that PR. I’ve met friends living all across the world. I can attribute a ton of forward momentum in my life directly to that moment. All I needed was that first push.</p><h3>Up Next: An Avalanche</h3><p>And of course, as with every coin, there is another side to consider. While I’m very sure I am not alone in the story I’ve told above, there are of course some negatives that have come along with it. While this annual event has certainly been great at driving contributions (apparently, people love(d) t-shirts), it also has a tendency to overwhelm already weary maintainers on small and large projects alike.</p><p>These projects, who in most cases would love the help, once a year find themselves facing an avalanche of issues and pull requests. And in some cases, it’s not exactly the additive contribution that they are looking for. In some cases, it’s just changing the order of words in a sentence or adding some unnecessary punctuation. All just to increase their contribution count.</p><p><em>This is not the way.</em></p><p>To be fair, as years have gone by, Hacktoberfest organizers have come up with better ways to help discourage this type of behavior. Instead of it being a free-for-all, things now are a bit more opt-in. In addition to this, maintainers have a few more tools at their disposal to mark this type of undesirable behavior. While I’m not sure exactly how many folks do this level of spelunking, if thorough enough it would certainly be possible to link someone back to their undesirable behavior during Hacktoberfest. So beware, your reputation is likely to follow you around depending on how you decide to act during this most code-filled of months, for better or for worse.</p><p>On the flip side though, as a maintainer I’ve tried to look at Hacktoberfest through a slightly different lens. Instead of seeing it as a burden to be overcome, I see it as a potential set of signals. While there are always going to be folks just looking to pump their numbers, I think the majority of folks are just looking for the right on-ramp. If I’m getting bad PRs or Issues, maybe those signals are telling me that some work is needed to make that on-ramp more approachable. So what if Hacktoberfest was instead an exercise in sanding down sharp edges. Work on making that CONTRIBUTING.md a little easier to interpret. Write up something that looks like My First PR. What I’ve come to find is that if we make the desired behavior the easy behavior, you tend to get where you want a lot faster.</p><h3>Go Forth, Together</h3><p>So my advice to everyone? <strong>Lean in.</strong> Everyone be cool, but the only way to proceed is together. The only way we continue to grow this ecosystem that we all love is by encouraging others to get involved and showing them the ropes.</p><p>So go forth. Be excellent to each other and enjoy your Hacktobering.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4703602c8a42" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[MetalLB and KinD: Loads Balanced Locally]]></title>
            <link>https://medium.com/@tylerauerbeck/metallb-and-kind-loads-balanced-locally-1992d60111d8?source=rss-eef929f68635------2</link>
            <guid isPermaLink="false">https://medium.com/p/1992d60111d8</guid>
            <category><![CDATA[kind]]></category>
            <category><![CDATA[local-development]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[metallb]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[Tyler Auerbeck]]></dc:creator>
            <pubDate>Tue, 24 Sep 2024 16:01:40 GMT</pubDate>
            <atom:updated>2024-09-24T16:01:40.789Z</atom:updated>
            <content:encoded><![CDATA[<h4>When You Need LoadBalancer Services On The Go, MetalLB and KinD Are There For You</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MUOdX4OocwYL0OXVCWf1tw.jpeg" /></figure><p>There are some blogs that no matter how many times you do something, you always come back to. Whether it’s because it’s complicated OR the fact that they’re just good and you decide that means you don’t need to commit them to memory — they just end up as part of your toolbox.</p><p>I recently had to revisit one of these oldie, but goodies and it struck me; tech blogs tend to age more like a bad cheese than a fine wine. Things are constantly moving. And while concepts will hold up, configs are generally a different story.</p><p>In my case, I wanted to spin <a href="https://github.com/metallb/metallb">MetalLB</a> up on <a href="https://github.com/kubernetes-sigs/kind">KinD</a> to support some testing that I was doing. The task at hand was simple. All I needed was the following:</p><ul><li>A Kubernetes Cluster</li><li>A CNI</li><li>The ability to create some LoadBalancer services</li></ul><p>So back to my dear old friend I went. But this time, things didn’t just work. I, as someone who frequently uses MetalLB, should have expected this. In versions since 0.13.2 there has been a switch from using a ConfigMap for configuration towards using a number of Custom Resource Definitions (CRDs). And yet, there I was.</p><p>Stumped.</p><p>So, in order to bring my future self some peace when I need to refer back to how do to this again, I figured it would be helpful (at least to myself, if nothing else) to write this down.</p><p>So let’s dive in.</p><p><strong>Step 1: Kubernetes Cluster</strong></p><p>The first thing I needed to do to get started was spin myself up a Kubernetes cluster. Since this was just testing out some bad ideas, I didn’t need anything robust, so spinning up KinD was more than plenty. For the purposes of our example, we’ll spin up a two node cluster by crafting the following config file (config.yaml) and applying it.</p><pre>---<br>kind: Cluster<br>apiVersion: kind.x-k8s.io/v1alpha4<br>nodes:<br>- role: control-plane<br>- role: worker</pre><p>With our configuration ready, we can then get things fired up by running:</p><pre>╰─❯ kind create cluster --config.yaml --name metallb-kind</pre><p>In this example, the above will create a cluster named metallb-kind , but please be aware that you can give your cluster whatever name you would like. Or you could just accept the default. Whatever you choose, just make sure if you’re running through this that you’re pointing yourself at the appropriate cluster and not firing this into a cluster that actually matters.</p><p>Once your cluster is up and running, you should have something that looks like the following:</p><pre>╰─❯ kubectl get nodes<br>NAME                         STATUS   ROLES           AGE     VERSION<br>metallb-kind-control-plane   Ready    control-plane   4m57s   v1.31.0<br>metallb-kind-worker          Ready    &lt;none&gt;          4m41s   v1.31.0</pre><p><strong>Step 1.5: Reach For Your Kubernetes Nodes</strong></p><p>Usually, just being able to access your kubernetes cluster is enough. However, with the testing that we want to do, we need to actually make sure that we can reach our Kubernetes nodes by address. Specifically, this is a test to make sure that our Docker network is reachable. Otherwise, trying to make any other additional addresses available to us would be pointless.</p><p>To begin this test, we’ll first grab the addresses associated with our KinD nodes. You can get these by running the following and grabbing the results under the INTERNAL-IP column:</p><pre>╰─❯ kubectl get nodes -o wide<br>NAME                         STATUS   ROLES           AGE   VERSION   INTERNAL-IP   EXTERNAL-IP   OS-IMAGE                         KERNEL-VERSION     CONTAINER-RUNTIME<br>metallb-kind-control-plane   Ready    control-plane   10h   v1.31.0   172.18.0.4    &lt;none&gt;        Debian GNU/Linux 12 (bookworm)   6.5.0-15-generic   containerd://1.7.18<br>metallb-kind-worker          Ready    &lt;none&gt;          10h   v1.31.0   172.18.0.5    &lt;none&gt;        Debian GNU/Linux 12 (bookworm)   6.5.0-15-generic   containerd://1.7.18</pre><p>Once you’ve got your addresses, a simple ping check will suffice to verify your connectivity.</p><pre>╰─❯ ping 172.18.0.4<br>PING 172.18.0.4 (172.18.0.4) 56(84) bytes of data.<br>64 bytes from 172.18.0.4: icmp_seq=1 ttl=64 time=0.065 ms<br>64 bytes from 172.18.0.4: icmp_seq=2 ttl=64 time=0.062 ms<br>64 bytes from 172.18.0.4: icmp_seq=3 ttl=64 time=0.042 ms</pre><p>If you’re seeing some responses, you’re good to go! Otherwise you may need to troubleshoot what may be in the way of your connectivity. This should work without much issue on Linux based operating systems, but in the likely chance that you’re using a machine with a nice fruit stamped on the lid, there may be some additional steps you need to take. If you’re searching for some assistance, <a href="https://medium.com/@tylerauerbeck/making-your-docker-network-reachable-in-osx-e68f998f8249">taking a look at this article may help</a>.</p><p><strong>Step 2: Sourcing Some Network Blocks</strong></p><p>At this point, we’ve got a cluster and we’ve verified that we can access the nodes. But now we need to source a pool of addresses that we can use to advertise our services with via MetalLB. Since we’re relying on the Docker networking that KinD is using, we’ll need to grab some unused address space from there. By default, the Docker network kind is used, so we can use tools like jq to poke at this a bit (unless you feel particularly inclined to eyeball this directly). The value we’re looking for will be buried under IPAM.Config in the subnet value. There may be more than one entry here, so what you’ll want to grab is the IPv4 subnet. If you don’t have any complex configurations in your docker network, then running the following will yield us what we’re looking for:</p><pre>╰─❯ docker inspect kind | jq .[].IPAM.Config<br>[<br>  {<br>    &quot;Subnet&quot;: &quot;fc00:f853:ccd:e793::/64&quot;<br>  },<br>  {<br>    &quot;Subnet&quot;: &quot;172.18.0.0/16&quot;,<br>    &quot;Gateway&quot;: &quot;172.18.0.1&quot;<br>  }<br>]</pre><p><strong>Step 3: Bringing MetalLB To Life</strong></p><p>At this point, we’ve got the values that we’ll need to get a basic MetalLB deployment up and running. To keep things simple, we’ll deploy the manifests provided by the MetalLB GitHub repo:</p><pre>╰─❯ kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.14.8/config/manifests/metallb-native.yaml</pre><p>If you prefer, you can also deploy this via Helm with the following:</p><pre>╰─❯ helm repo add metallb https://metallb.github.io/metallb<br>╰─❯ helm install metallb metallb/metallb</pre><p>Whatever path you choose, what you should end up with is a functioning MetalLB deployment of a single controller and two speaker pods based on the cluster that we’ve created.</p><pre>╰─❯ kubectl get pods -n metallb-system<br>NAME                          READY   STATUS    RESTARTS      AGE<br>controller-8694df9d9b-fhkp2   1/1     Running   0             1d<br>speaker-5xc9r                 1/1     Running   0             1d<br>speaker-as78d                 1/1     Running   0             1d</pre><p><strong>Step 3.5 — Configuring MetalLB</strong></p><p>Now that we’ve got a functional instance of MetalLB, we can make sure that it’s configured correctly to use the network ranges that we dug up earlier. As I mentioned, in previous versions this was managed via a ConfigMap. However, in recent versions there are now a number of CRDs that are available to us. The resources that we’re interested in for this example are the ipaddresspools and l2advertisements . If you’re interested in the other CRDs that are available, you can check out this listing via doc.crds.dev .</p><p><a href="https://doc.crds.dev/github.com/metallb/metallb">metallb/metallb</a></p><p>To begin, we’ll need to create one of each of the above. The first will be an empty l2advertisement and the other will be an ipaddresspool containing a small portion of the subnet that we gathered earlier.</p><pre>---<br>apiVersion: metallb.io/v1beta1<br>kind: IPAddressPool<br>metadata:<br>  name: demo-pool<br>  namespace: metallb-system<br>spec:<br>  addresses:<br>  - 172.18.255.1-172.18.255.25  <br>---<br>apiVersion: metallb.io/v1beta1<br>kind: L2Advertisement<br>metadata:<br>  name: demo-advertisement<br>  namespace: metallb-system</pre><p>This is probably larger than whatever we’ll need to run locally, but we may as well give ourselves some room to grow while we’re here. Once we have the above in place, MetalLB will be ready for any service that applies the appropriate annotations requesting an address.</p><p><strong>Step 4 — Creating A LoadBalancer Service</strong></p><p>Now that MetalLB is up and running, we can begin to create services that will utilize it. For a quick test, I’ll rely on an old favorite: http-echo . To test this out, you can create the following deployment and service to get started.</p><pre>---<br>apiVersion: v1<br>kind: Namespace<br>metadata:<br>  name: echo<br>---<br>apiVersion: apps/v1<br>kind: Deployment<br>metadata:<br>  name: echo<br>spec:<br>  replicas: 1<br>  selector:<br>    matchLabels:<br>      app: echo<br>  template:<br>    metadata:<br>      labels:<br>        app: echo<br>    spec:<br>      containers:<br>        - name: echo<br>          image: hashicorp/http-echo<br>          args:<br>            - -listen=:8080<br>            - -text=&quot;hello there&quot;<br>          ports:<br>            - name: http<br>              containerPort: 8080<br>---<br>apiVersion: v1<br>kind: Service<br>metadata:<br>  name: echo<br>spec:<br>  ports:<br>    - name: http<br>      port: 80<br>      targetPort: http<br>      protocol: TCP<br>  selector:<br>    app: echo<br></pre><p>With the above applied, you should be able to see a running echo pod in the echo namespace. You’ll also see that you’ve got yourself a regular ol’ service there as well.</p><pre>╰─❯ kubectl get svc -n echo<br>NAME   TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)   AGE<br>echo   ClusterIP   10.96.173.217   &lt;none&gt;        80/TCP    2m40s</pre><p>That’s great to get us started. But we want a LoadBalancer service to make use of that sweet MetalLB magic! So let’s make a few modifications. There are two things we’ll need to add/update with our service defintion.</p><pre>---<br>apiVersion: v1<br>kind: Service<br>metadata:<br>  annotations:<br>    metallb.universe.tf/address-pool: demo-pool<br>  name: echo<br>spec:<br>  ports:<br>    - name: http<br>      port: 80<br>      targetPort: http<br>      protocol: TCP<br>  selector:<br>    app: echo<br>  type: LoadBalancer</pre><p>The two areas that we’re interested in live under the annotations and type fields.</p><p>The first, fairly self-explanatory change is to the type field. We want to specify that we want this to be of type LoadBalancer so that we can get an external IP assigned to our service.</p><p>Next, we’ll want to add a MetalLB specific annotation to our service so that the MetalLB controller knows that it needs to take action on it. MetalLB annotations can allow you to take a number of actions such as targeting a specific pool, a specific address and much more. In our case, we’re just going to target the pool that we created earlier (because in our case — we don’t care what specific address gets used). The pool we created was named demo-pool , so we’ll add the annotation metallb.universe.tf/address-pool: demo-poolto our service. After applying our new annotation, our service should look more like the following with a shiny new address that we can reach it at.</p><pre>╰─❯ kubectl get svc -n echo<br>NAME   TYPE           CLUSTER-IP      EXTERNAL-IP      PORT(S)        AGE<br>echo   LoadBalancer   10.96.190.254   172.18.255.200   80:30216/TCP   2m21s</pre><p>At this point, we can see that the service was updated to be of type LoadBalancer and that an address has been assigned from our pool under EXTERNAL-IP . From here, a quick curl should suffice to prove that this is all functioning as expected.</p><pre>╰─❯ curl http://172.18.255.200<br>&quot;hello there&quot;</pre><p>SUCCESS! We’ve got MetalLB running and configured, we’ve got an app running and we’ve advertised an address that we can hit it directly on. We’ve got the whole world in front of us! I mean really, we do. This is a pretty basic example and there’s a ton of more exciting things that we can do now that we’ve confirmed our basic configurations are in place.</p><p>But, for the purposes of this blog, we’ve accomplished what we’re looking for. We’ve got a KinD cluster and MetalLB up and working together. Personally, this is a huge benefit to me as while KinD is more than capable of poking some holes and making things available via certain ports — it’s always been much more beneficial to me to run something that looks more like my production environment. So being able to test out and play with the tools that I actually use has drastically reduced the number of lumps that I need to take during my deployments and vastly sped up my development loops.</p><p>Hopefully this provides you some similar benefit for any local development you’ve got planned!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1992d60111d8" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>