<?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 Esteban Puello on Medium]]></title>
        <description><![CDATA[Stories by Esteban Puello on Medium]]></description>
        <link>https://medium.com/@eftech93?source=rss-eda0dd494816------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*T2j27QyaV6UROo0ROItOOQ.png</url>
            <title>Stories by Esteban Puello on Medium</title>
            <link>https://medium.com/@eftech93?source=rss-eda0dd494816------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 01:42:21 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@eftech93/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[Pin your Docker images by digest: how a rebuilt tag broke my upgrade test]]></title>
            <link>https://medium.com/@eftech93/pin-your-docker-images-by-digest-how-a-rebuilt-tag-broke-my-upgrade-test-e649b4597279?source=rss-eda0dd494816------2</link>
            <guid isPermaLink="false">https://medium.com/p/e649b4597279</guid>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[postgresql]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Esteban Puello]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 15:01:04 GMT</pubDate>
            <atom:updated>2026-11-16T15:01:04.117Z</atom:updated>
            <content:encoded><![CDATA[<p>My upgrade test said the new version of my index returned different answers. It hadn’t changed a thing.</p><p>Before I release a new version of my vector index inside PostgreSQL, I run one test. I saved the old version’s top 10 results for 1,000 queries, and the new version has to return the same answers. If they differ, something broke.</p><p>This time, 57 of the 1,000 came back with a different top 10.</p><h3>Suspect one: my own changes</h3><p>I went through my changes first. None of them should have changed the answers. That left the uncomfortable possibility that something under my code had moved.</p><h3>The image had changed under the same name</h3><p>My build starts from the official pgvector Docker image, and I referenced it the way most people do, by its tag. Between the day I saved the reference answers and the day I ran the test, that image had been rebuilt upstream and pushed under the same tag.</p><p>Same name, different contents. My Dockerfile hadn’t changed, and neither had my code, but the base under both had.</p><p>A Docker tag is a label that can be moved. A digest is a hash of the image’s contents, and it can’t. To see the digest of the image you have:</p><pre>docker pull pgvector/pgvector:pg17<br>docker inspect --format &#39;{{index .RepoDigests 0}}&#39; pgvector/pgvector:pg17</pre><p>Then reference it in the Dockerfile:</p><pre>FROM pgvector/pgvector:pg17@sha256:&lt;digest&gt;</pre><p>Now the build only changes when I change that line. The digest from RepoDigests is the multi-architecture one, so the same pin works on amd64 and arm64 machines.</p><h3>The second cause was quieter</h3><p>Pinning the image took the differences from 57 queries to 10. The rest came from the build itself.</p><p>Building an index with several workers in parallel isn’t perfectly deterministic: the workers add points to the index at the same time, so a few of the links between points depend on timing. Two parallel builds of the same data agreed on 990 of 1,000 queries, not all 1,000. Built by a single process, the index came out identical every time I built it.</p><p>So the reference index is now built in one process. Parallel builds are still fine for everything else; only the reference has to be exactly reproducible.</p><h3>Result</h3><p>With the image pinned by digest and the reference built in one process, the new version returns the old version’s answers on 1,000 of 1,000 queries, and accuracy didn’t move.</p><h3>What I took from it</h3><ul><li>A test is only as reproducible as the build under it.</li><li>Pin base images by digest in anything that compares results over time: benchmarks, regression tests, reference data.</li><li>When parallelism can change results, build references in a single process, and say so in the test.</li><li>A Docker tag is a name, not a version.</li></ul><p>What do you pin in your builds that you used to trust?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e649b4597279" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The cleanup nobody benchmarks]]></title>
            <link>https://medium.com/@eftech93/the-cleanup-nobody-benchmarks-fc3905314720?source=rss-eda0dd494816------2</link>
            <guid isPermaLink="false">https://medium.com/p/fc3905314720</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[benchmark]]></category>
            <category><![CDATA[postgresql]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[vector-database]]></category>
            <dc:creator><![CDATA[Esteban Puello]]></dc:creator>
            <pubDate>Thu, 12 Nov 2026 15:01:04 GMT</pubDate>
            <atom:updated>2026-11-12T15:01:04.868Z</atom:updated>
            <content:encoded><![CDATA[<p>Deleting a quarter of a million vectors, in two rounds, cost pgvector over twelve hours of cleanup.</p><p>The delete itself was instant. The bill came afterwards.</p><p>I build my own vector index inside PostgreSQL, and most of my benchmarks look like everyone else’s: load the data, build the index, run the queries, measure speed and accuracy. That picture has a hole in it. Real data doesn’t sit still. Products get discontinued, documents get removed, users ask to be forgotten. And in PostgreSQL, deleting a row is only half the job.</p><h3>Deleting is cheap. Cleaning up isn’t.</h3><p>When you delete rows in PostgreSQL, they don’t disappear. They’re marked as dead, and a later step called VACUUM does the real work: it removes the dead rows and fixes every index that still points at them. For a plain table that’s routine. For a vector index, fixing it can mean repairing the structure the search depends on.</p><p>So I added a test that most vector benchmarks skip. I took 1 million vectors, built each index, deleted 10% of the rows and ran VACUUM, then deleted another 15%, a quarter of the original million in total, and ran VACUUM again. PostgreSQL had a 2 GB buffer pool, the memory it keeps for data and indexes. I timed each cleanup and checked the size of each index and the accuracy of the search afterwards.</p><h3>Twelve hours</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Qj8DJSgeDNuOryrTeMngBQ.png" /></figure><p>pgvector’s HNSW index took 5.9 hours to clean up after the first delete, and 6.5 hours after the second. Its smaller halfvec version, which stores each number in half the space, was barely faster: 5.0 and 5.3 hours. And when the cleanup was done, the HNSW index was still 8,184 MB. Cleaning up didn’t make it any smaller.</p><p>My first thought was that this was a memory problem. With a 2 GB buffer pool, an 8 GB index can’t fit, so maybe the hours were spent waiting on the disk. So I ran it again with 32 GB, enough for everything, and warmed it all up first. The cleanup was about a quarter faster, and still took 4.3 and 4.8 hours. The hours aren’t disk reads. They’re the work of repairing the graph itself.</p><p>My own index took 124 seconds after the first delete and 129 seconds after the second. That’s more than 170 times faster than HNSW on the same data, with the same 2 GB buffer pool.</p><h3>My first version had its own problem</h3><p>I’d love to say that was the whole story. It wasn’t.</p><p>The first version of my index cleaned up fast, but it never gave the space back. After both deletes it was still 1,633 MB, bigger than the 856 MB it had been when I built it. The dead entries were gone from the search, but the file kept their old pages for reuse and never shrank. For a test that runs once, nobody notices. For a table that loses rows every day, that’s a slow leak.</p><p>The fix makes the index give that space back during cleanup. After the two deletes it now sits at 772 MB and then 644 MB, close to the size of the data that’s actually left.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j8V4wkjEdYV0Ds0lQ9zu6g.png" /></figure><p>It wasn’t free. Cleanup got 20 to 30% slower: from 95 and 108 seconds to the 124 and 129 above. I took that trade. A slower cleanup that returns the space is better than a fast one that doesn’t.</p><p>Accuracy dipped slightly. Over the rows that remained, my index found 99.18% of the true nearest neighbours before the deletes and 99.07% after both, while HNSW held steady. A small slide, but a real one, and the kind I’ll keep watching as deletes pile up.</p><h3>Where pgvectorscale wins, and what it pays for it</h3><p>I also ran pgvectorscale, and it deserves an honest paragraph, because on cleanup it’s faster than mine.</p><p>Its cleanup took 14 seconds after the first delete and 18 after the second. Its index is also smaller than mine when built: 682 MB against my 856.</p><p>It seems to get that speed by deferring the work. Its cleanup appears to leave the deleted entries in its graph instead of repairing around them: its index didn’t shrink. It pays for that later, when new vectors arrive. After the two deletes, adding a vector took 92 milliseconds on pgvectorscale, up from 27 on the freshly built index, against 9.8 on mine. Building the index is also much slower: 4,814 seconds against my 257, about 19 times longer.</p><p>So there’s no single winner here. If your data mostly grows and rarely changes, pgvectorscale’s fast cleanup and small index are hard to argue with. If you insert all day, or rebuild often, the cost shows up somewhere else. What matters is that you measure the part your workload actually does.</p><h3>What I’m taking from this</h3><p>A benchmark that stops after the queries describes an index on its first day. The second day, when rows start to disappear, can cost hours, and none of the usual numbers will warn you.</p><p>So my benchmarks now measure the day after: delete, clean up, check the size, check the accuracy, insert again.</p><p>Does your vector benchmark measure what happens after deletes, or only queries and inserts?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fc3905314720" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What changing the bin’s shape did to my robot]]></title>
            <link>https://medium.com/@eftech93/what-changing-the-bins-shape-did-to-my-robot-cba0baa3bd33?source=rss-eda0dd494816------2</link>
            <guid isPermaLink="false">https://medium.com/p/cba0baa3bd33</guid>
            <category><![CDATA[simulation]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[reinforcement-learning]]></category>
            <category><![CDATA[robotics]]></category>
            <category><![CDATA[engineering]]></category>
            <dc:creator><![CDATA[Esteban Puello]]></dc:creator>
            <pubDate>Mon, 09 Nov 2026 18:47:56 GMT</pubDate>
            <atom:updated>2026-11-09T18:47:56.458Z</atom:updated>
            <content:encoded><![CDATA[<p>Every bin my robot had ever picked from was the same box.</p><p>That’s fine in a simulator. It’s not fine anywhere else. A real cell has whatever bin the factory already owns: a bit wider, a bit longer, deeper than you’d like. Before I train my robot on bins of many shapes, I wanted to know what a new shape breaks on its own.</p><p>So I built four new bins in my bin-picking simulation: one wider, one longer, one shallower and one deeper than the standard. Then I ran two robots on each of them. The first is the planner that teaches my learned policy, the part that is supposed to just work. The second is the policy itself, which had only ever seen the standard bin.</p><p>Everything here is simulation. Each arm and each shape got 16 piles of 20 parts, and I counted two things: how many parts it placed in the first minute, and how many bins it emptied completely.</p><h3>The first run dropped parts over the wall, and it wasn’t the robot’s fault</h3><p>The very first wide-bin run went badly. The planner picked parts fine, carried them over and then dropped them outside the other bin.</p><p>The bug was in my world, not in the robot. When I widened the bin it picks from, the bin it places into quietly took the same new size in my code. The planner aimed its release over a bin that was wider than the real one, and let go over the wall.</p><p>Each bin now keeps its own size, and the place bin never moves closer to the pick bin than a fixed gap. A small fix, but it set the tone for the week: when a result looks strange, check the world before the robot.</p><h3>Wider, longer, shallower: the planner barely noticed</h3><p>With that fixed, the planner shrugged off most of the new shapes.</p><p>In the wider and the shallower bins it placed about 19 to 20 parts in the first minute and emptied every bin on the xArm6, the FR3, the LR Mate and the UR5e. The wider bin even helped one arm: the iiwa, which struggles to reach the far corner of the standard bin, emptied 69% of the wider bins against 22% of the standard ones. Its hardest corner had simply moved closer.</p><p>The longer bin cost one to one and a half parts a minute on three of the arms. Its far end is further from the robot, and every trip there takes a little longer. That’s not a bug. That’s distance.</p><h3>The learned policy held on, until the rim moved</h3><p>The policy had never seen any of these shapes, so I expected it to suffer everywhere. It didn’t.</p><p>In the wider and longer bins it stayed close to its standard-bin numbers. I tried it on three arms. On the xArm6 it placed about 17 parts a minute in both and emptied every bin. On the FR3 and the UR5e it emptied 94 to 100%.</p><p>The shallower bin was different. There it lost two to four parts a minute on all three arms I tried it on, and emptied only 62 to 75% of the bins. My guess at the reason: the policy doesn’t see how high the rim is, it only sees the parts. Every bin it trained on had its rim in the same place, and the shallow bin’s rim sits lower than any of them. Whatever it learned about clearing the wall, it learned for one wall.</p><p>That is the clearest argument I have for the next step: train it on worlds of several shapes, so the rim stops being a constant.</p><h3>The deep bin: 94 seconds without closing the hand</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*T4d_TxMacSPp5NGYG3_FnQ.gif" /><figcaption>The planner in the deep bin, simulation, played at twice the speed. The counter stays at 17 of 20 while the hand keeps going back to the wall.</figcaption></figure><p>The deeper bin is where the story turned.</p><p>I watched the planner on the xArm6. It started as fast as ever, ten parts in under 24 seconds. Then it reached the last parts, which had settled along the far wall, and it stopped closing its hand. From 50 seconds to 144 seconds, not a single grasp.</p><p>The video showed the same move again and again. The hand went down beside the wall, the safety check refused the move, the arm backed off and went down again. Four times a second.</p><p>I already had a rule for this. My first deep-bin run had shown the same loop for 12 seconds, so I’d taught the planner to give up on a spot after four refusals and pick somewhere else. In the deep bin that rule fired as designed, and it didn’t help. The next spot it chose was only 3 to 5 cm away, by the same wall, and it was refused the same way. Spot after spot, four refusals each. That’s where the 94 seconds went. It did empty the bin in the end, at 176 seconds.</p><h3>It wasn’t the hand</h3><p>My first suspect was the hand hitting the wall. It wasn’t.</p><p>The fingers on this gripper are long. In the standard bin, when the hand reaches the floor, the base of each finger is still above the rim. In the deeper bin it isn’t: the base of the outer finger ends up below the rim, a few millimetres inside the wall itself. No grasp at those spots was ever possible. The safety check was right every single time.</p><p>To be sure it was the depth and not the pile, I ran the same pile in bins of 1.0, 1.1, 1.2 and 1.3 times the normal depth and counted the refused moves in the first minute:</p><ul><li>1.0, 1.1 and 1.2 times as deep: zero.</li><li>1.3 times as deep: 74.</li></ul><p>The parts settle the same way in both bins, to within a few millimetres. It’s the wall.</p><p>Across all six arms, the planner emptied at most 38% of the deep bins. The learned policy, on the three arms I tried, emptied at most 12%.</p><h3>What I changed, and what I didn’t</h3><p>I didn’t make the planner smarter. A real cell would solve this with hardware: longer fingers or a shallower bin. Software that keeps trying a grasp the geometry forbids is just a slower way of failing.</p><p>So the training worlds stay at 1.2 times the standard depth or less, until each arm gets its own gripper with its own fingers. The four-refusal rule stays too, because it’s still the right answer when one spot is blocked and the next one isn’t.</p><p>And the learned policy gets its next job: training on bins of several shapes, so a lower rim stops surprising it.</p><h3>What I’m taking from this</h3><p>Three of four new shapes cost almost nothing, which is good news for a simulator meant to train for real cells. The one that hurt didn’t hurt because of learning or planning. It hurt because of a few centimetres of finger.</p><p>When a robot keeps retrying, check the geometry before the logic.</p><p>What’s the physical limit your software spent the longest trying to work around?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cba0baa3bd33" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My benchmark fooled me three times]]></title>
            <link>https://medium.com/@eftech93/my-benchmark-fooled-me-three-times-6060c433c9f6?source=rss-eda0dd494816------2</link>
            <guid isPermaLink="false">https://medium.com/p/6060c433c9f6</guid>
            <category><![CDATA[benchmark]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[postgresql]]></category>
            <category><![CDATA[vector-database]]></category>
            <dc:creator><![CDATA[Esteban Puello]]></dc:creator>
            <pubDate>Wed, 04 Nov 2026 15:01:04 GMT</pubDate>
            <atom:updated>2026-11-04T15:01:04.857Z</atom:updated>
            <content:encoded><![CDATA[<p>Last week I told people my vector index was about twice as fast as pgvector. A few days later I found out that pgvector had been running with one hand tied behind its back.</p><p>It was the third time in two weeks that my own benchmark had fooled me. This is the story of all three, and of what is left once you remove them.</p><h3>Why I started</h3><p>At work, I was optimizing an Aurora PostgreSQL cluster that runs pgvector. pgvector stores embeddings next to the rest of your data and searches them with an HNSW index, a graph that finds the nearest vectors quickly.</p><p>The catch is memory. HNSW is fast when most of the graph stays in memory. With millions of vectors, that memory becomes the expensive part of the bill.</p><p>So I started building my own index inside PostgreSQL, to see if there was another way. The results below are early, from a shared server, and I’m keeping the method for the paper.</p><p>To compare the two fairly, I wrote a benchmark: same table, same queries, same accuracy target (about 99% of the true nearest neighbours found), and what I believed were pgvector’s best settings.</p><p>The “true” nearest neighbours come from an exact brute-force search over the same rows, using 1,000 queries kept separate from the indexed data. Both indexes are scored against that same answer key, by the same code.</p><p>That benchmark is where things went wrong.</p><h3>Lie 1: I was timing two different things</h3><p>On 100,000 vectors, my first chart said pgvector took 6.8 ms per query and my index 1.4 ms. Five times faster.</p><p>Those were the times spent inside the index only. A real query also has to read rows, sort them and send them back. The full query in the same log took 8.2 ms against 2.5 ms.</p><p>About three times faster. Still a good result, just not the one I almost published.</p><p>The fix was simple: always time the whole query, the way an application would see it.</p><h3>Lie 2: I built pgvector’s index with too little memory</h3><p>My first build-time number said my index built 20 times faster.</p><p>Then I looked at how pgvector had been built. PostgreSQL gives an index build a fixed amount of working memory, and I had left it at 2 GB. pgvector’s graph for a million vectors needs more than 6 GB while it builds: the vectors alone are 6 GB, before the links between them. It didn’t fit, so most of the build ran in a much slower mode that works on disk.</p><p>With enough memory and the same number of workers on both sides, pgvector builds that index in about 35 minutes. Mine takes about 4.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OBlQjXE_pY3q5pb48Ms3wg.png" /></figure><p><em>Build time with pgvector given 16 GB and 7 parallel workers. Shared server, preliminary.</em></p><p>Still a large gap. But about 8 times, not 20.</p><h3>Lie 3: I searched pgvector’s index with too little memory</h3><p>This one I only found last week, and it changed the headline.</p><p>PostgreSQL keeps a cache of data in memory, called shared buffers. My tests used 2 GB, a normal value. But pgvector’s index for a million vectors is 8.2 GB. It could never fit in that cache, so every query had to fetch thousands of index pages from outside it.</p><p>My index is under 1 GB. It fit easily.</p><p>So the “twice as fast” I had reported was partly a measure of who fit in memory. I ran the test again with 2, 4, 8, 16 and 32 GB of cache.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uRHkBvi1R77uCiUL9EXtPA.png" /></figure><p><em>Query time against PostgreSQL’s cache size, 1 million vectors, about 99% recall. The dotted lines mark where each pgvector index fits in memory.</em></p><p>With 2 GB, my index is about twice as fast. Once pgvector’s index fits, at 4 GB for its compressed version and 8 GB for the full one, the typical query takes about the same time on both: 8 to 10 milliseconds. On the slowest queries, pgvector is now ahead.</p><p>That stung. It also made the result clearer than before.</p><h3>What still holds</h3><p>Take away all three mistakes and this is what’s left.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cqyiQwPpNcZ2EhqzECflJA.png" /></figure><p><em>Index size on disk. Shared server, preliminary.</em></p><p>My index is about a tenth of the size: 856 MB against 8.2 GB for a million vectors. To answer at full speed, pgvector needs memory for its whole index. Mine needs less than 1 GB.</p><p>It builds about 8 times faster, and inserting a new row costs a quarter or less of what it costs in pgvector.</p><p>So the honest summary is: same speed when memory is plentiful, much faster when it isn’t, and a tenth of the memory either way. Since memory was the reason I started, that’s the result I care about.</p><h3>What I check now before I trust a benchmark</h3><ul><li>Time what the user waits for: the full query, not one stage of it.</li><li>Give the other side its best settings, then check them again. Read how it was built, not only how it was searched.</li><li>Treat memory as a variable. Run the test at more than one cache size, and say which one you used.</li><li>Report the slow queries too. A median can hide a bad tail.</li><li>Run it more than once and report ranges. On my shared server, build times moved by 10 to 25% between runs.</li><li>Before publishing, ask one question: what would make the other side win? Then go and test that.</li></ul><p>Each of the three mistakes made my index look better. None of them was on purpose. That’s what makes them dangerous: when the numbers say what you hoped, you stop looking.</p><p>If you benchmark databases: which setting has fooled you the most ?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6060c433c9f6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I found my simulator’s bug by watching my robot’s video]]></title>
            <link>https://medium.com/@eftech93/i-found-my-simulators-bug-by-watching-my-robot-s-video-6c8fb15bf5a8?source=rss-eda0dd494816------2</link>
            <guid isPermaLink="false">https://medium.com/p/6c8fb15bf5a8</guid>
            <category><![CDATA[rust]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[simulation]]></category>
            <category><![CDATA[robotics]]></category>
            <category><![CDATA[reinforcement-learning]]></category>
            <dc:creator><![CDATA[Esteban Puello]]></dc:creator>
            <pubDate>Tue, 03 Nov 2026 15:01:05 GMT</pubDate>
            <atom:updated>2026-11-03T15:01:05.586Z</atom:updated>
            <content:encoded><![CDATA[<p>Last Wednesday I posted a video of a robot arm emptying a bin of 20 parts in simulation. One trained network, k12, driving a UFactory xArm6. It placed 19 of the 20 parts in 72 seconds, and I was happy with it.</p><p>Then I watched it again.</p><p>At 14 seconds the arm releases a blue cylinder over the target bin. The fingers open. The cylinder doesn’t fall. It stays on the open fingers and rides all the way back to the source bin.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*0T7zyWrg-yxbKQtU9KgsDQ.gif" /></figure><p><em>The released cylinder rides back to the source bin on the open fingers (simulation, 1x speed).</em></p><p>A real gripper can’t do that. An open hand holds nothing. Watching more closely, I also saw fingers pass into parts instead of stopping on them. The network wasn’t doing anything wrong there. The simulator was letting it get away with things.</p><p>This is the story of fixing that, and of what the fix did to the numbers.</p><h3>The setup</h3><p>I’m training a policy to pick parts from a cluttered bin and place them in a second bin, entirely in a simulator I wrote in Rust.</p><p>The network that runs the arm is a student. It only sees depth, from two simulated cameras: one over the bin and one on the wrist. It learned from a planner, the teacher, that sees the exact pose of every part and can try a grasp in a copy of the simulation before committing to it. The student has none of that. It has to work from what the cameras see.</p><p>k12 was trained on two arms, a Franka FR3 and a UFactory xArm6, three variants of each. It also has to move within each arm’s real joint speed and acceleration limits, so the same network moves the two arms differently.</p><p>The benchmark is 32 piles of 20 parts per arm, up to 180 seconds each. I score two things: how many parts are placed in the first 60 seconds, and the share of bins emptied. I also run it on two arms it never trained on, a KUKA iiwa and a Kinova Jaco2, to see how far it generalizes.</p><h3>Why a stuck part matters</h3><p>A part stuck on the fingers looks like a cosmetic bug. It isn’t.</p><p>A policy trained in a simulator learns the simulator, not the world. If open fingers can carry a part, a policy can learn to rely on it. If a finger can sink into a part instead of stopping, a policy can learn grasps that would fail on a real gripper, or would push the part and the bin around on a real cell.</p><p>Every way the simulator is more generous than reality is a way for the benchmark to look better than the robot would be. So the goal is a strict simulator, even if it makes the numbers worse.</p><h3>The three fixes</h3><p>All three are in the contact handling, how the simulator decides what happens when a finger touches a part.</p><p><strong>1. A finger pushed into a part stops the arm.</strong> Real arms have collision detection: push into something hard enough and they stop. The simulator now does the same. When a finger goes more than 3 mm into a part, the arm stops.</p><p>The first version of this had a subtle leak. Each stop held the posture from just before the limit was crossed, and that posture was a little deeper every time. A finger pressed into a part crept from 3.4 mm to 7.7 mm deep over 0.6 seconds, one stop at a time. Now a second stop in a row holds exactly where the first one did.</p><p><strong>2. An open hand lets go.</strong> Friction between an open finger and a part it’s buried in is now cut. The first version cut it one contact patch at a time. A shallow patch next to the deep one, same finger, same part, kept its friction, and in one case lifted a part 16 cm on a single open finger. Now friction is cut for every contact between that finger and that part.</p><p><strong>3. The hand stays fully open over the target bin</strong>, so it can’t close again on the part it just released.</p><p>Measured per physics step, k12 on 4 piles:</p><ul><li>the deepest a finger goes into a loose part fell from 21–32 mm to 9–13 mm</li><li>parts hang on open fingers for 1.3 s in total across the 4 piles, against 5–17 s before, and never longer than 0.1 s at a time</li></ul><h3>What it did to the run</h3><p>Same pile, same network, unchanged:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*z96on31fDE-MXTKD16rcPQ.gif" /></figure><p><em>Same network, improved simulator: the last parts, finishing at 59.4 s (simulation, 1x speed).</em></p><p>The xArm6 now empties the source bin at 59.4 seconds, down from 72. It’s the first run on this pile to finish inside 60 seconds. 19 of 20 are placed. The 20th was thrown over the wall between the bins by a lost grasp at 23.8 seconds, and ended up outside both bins.</p><p>On both arms, no released part stays on the fingers anymore, and every release lands in the target bin.</p><p>The FR3 is the honest counterexample. On the same pile it placed 18 and finished at 93 seconds, against 19 placed by 89 seconds in the video I posted on Thursday. Most of the difference is lost grasps.</p><h3>The benchmark, before and after</h3><p>Same k12, only the simulator changed. Parts placed in the first 60 s, and bins emptied:</p><ul><li><strong>xArm6:</strong> 15.8, 94% → 17.5, 100%</li><li><strong>FR3:</strong> 16.2, 81% → 16.2, 88%</li><li><strong>iiwa (never trained on):</strong> 14.0, 19% → 13.6, 25%</li><li><strong>Jaco2 (never trained on):</strong> 7.4, 59% → 7.7, 62%</li></ul><p>The gain is mostly on one arm. The xArm6 now clears every pile. The FR3 places the same number in 60 seconds but empties more bins. The iiwa places slightly fewer parts in the first minute, 0.4 fewer, even though it empties more bins. The Jaco2 barely moves, and it’s still where the policy clearly struggles.</p><p>I also tried retraining: a version of k12 trained with the bin walls and the table stopping the fingers too. It was no better on any arm, so k12 stays.</p><h3>What’s still open</h3><p>Two things still cost time.</p><p><strong>Lost grasps.</strong> A part slips out of the hand on the way to the target bin. Each one costs about 1.5 seconds, and this one pile had 4 on the xArm6 run and 7 on the FR3 run. Two of them threw a part out of play.</p><p><strong>Flat parts against a bin wall.</strong> On the FR3 run the hand spent 15 seconds working over two flat parts stacked against the source bin’s wall.</p><p>When I dug into the lost grasps, they turned out to be the simulator too. That fix, and what it did, is this Saturday’s post.</p><h3>What I took from it</h3><p><strong>Watch the videos, not only the score.</strong> The benchmark number was fine. The bug was only visible in the video, at 14 seconds, for half a second.</p><p><strong>A generous simulator inflates everything.</strong> It inflates the score, the confidence in the policy, and the gap you’ll find later on hardware. Fixing the simulator moved this benchmark more than retraining did.</p><p><strong>Strict before real.</strong> All of this is simulation. Before going anywhere near hardware, I want the simulator to fail the policy for anything a real gripper couldn’t do.</p><p>If you work with simulated robots: how do you catch a simulator bug before your policy learns to use it ?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6c8fb15bf5a8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Bring more value to clients using the 3Us principle applied on software development]]></title>
            <link>https://medium.com/@eftech93/bring-more-value-to-clients-using-the-3us-principle-applied-onsoftware-deveolpment-8fa59e7815e3?source=rss-eda0dd494816------2</link>
            <guid isPermaLink="false">https://medium.com/p/8fa59e7815e3</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[value-proposition]]></category>
            <category><![CDATA[evaluation]]></category>
            <dc:creator><![CDATA[Esteban Puello]]></dc:creator>
            <pubDate>Mon, 15 Jan 2024 15:22:13 GMT</pubDate>
            <atom:updated>2024-03-05T14:43:59.938Z</atom:updated>
            <content:encoded><![CDATA[<p>While being interviewed by <a href="https://www.linkedin.com/in/cindy-sandoval-castro-082722132/">Cindy</a> from <a href="https://www.linkedin.com/company/chronoinnovation/mycompany/">Chrono Innovation</a>, she asked (paraphasing) about how do I handle to provide value to our clients when developing systems / features; right away, I thought about the <strong>3U Principle</strong> (Useful, Usable and Used) that lately I’ve applied for any development, which have seemed to <strong>give great results</strong>. So let’s define each of those Us and the see how <strong>to evaluate and to score</strong> a feature.</p><h3>Useful</h3><p>Usefulness can be translated to the <strong>benefit that the user will obtain or obtained</strong> by using the system/feature.</p><p>How can you make sure that a what’s being developed is useful? easy, <strong>work closer with your user or potential user while developing</strong>, the closer the cycle between developing and user testing, <strong>the better</strong>. You can even<strong> allow your user to test while you are developing</strong>, this shorten the distance between your end user and your understanding of a feature; plus <strong>allows you to have more feedback</strong>.</p><p>Other ways to determine if a system or feature will be useful is by <strong>interviewing or performing workshops</strong> with your clients or potential clients, to extract <strong>as much information as possible</strong>. Then, use the information to create “features” and classify them by using the following scale:</p><ol><li><strong>We will not eat if we do not have the feature / I cannot work without this feature:</strong> this means that its not only important but also urgent (this is the type of feature you should be focusing on).</li><li><strong>This will save so much time / This is a game changer:</strong> this means that you will give back a lot of time to the user, which is a great sign.</li><li><strong>This is cool / Nice to have / In the future / I would like to have it: </strong>this means no need to put effort.</li></ol><p>I always suggest to <strong>avoid</strong> using words like <strong>important or urgent</strong>, because it becomes harder to actually classify and <strong>provides the wrong perception</strong> to your stakeholders / clients / users.</p><h3>Usable</h3><p>Usable as it can implied, refers to how easy to use / how easy to learn a feature or the system is. Usually usability can be seen in two different perspective: <strong>UX/UI perspecive</strong> and <strong>Architectural perspective</strong>.</p><p>It’s really common to find that many software products lack a <strong>user-centric vision</strong> due to developers not being UX/UI experts or architects (both visions tackle usability in different ways), which can make the final product unattractive for users or harder to use.</p><h4><strong>UX/UI expert vision</strong></h4><p>The UX/UI expert will look into structuring flow and interfaces in a way that makes the user’s journey <strong>simpler and more</strong> <strong>efficient</strong>. By reducing the number of steps in a flow, by reducing the amount of information shown, or by creating consistency between different pages.</p><h4><strong>Solution architect vision</strong></h4><p>Solution architects (SA) usually care more about error amendment and learning rates. Usually the SA should answer to the following questions:</p><ul><li>Can the system be able to revert an error performed by the user?</li><li>How long the system can handle the change for?</li><li>How long does it takes for an user to be autonomous while using the system?</li></ul><h4>Mixing visions</h4><p>While being a developer is already a hard profession, adding these types of vision can lead to a better systems and happier users.</p><h3>Used</h3><p>Is the system or feature used by many users? Developing is always nice, but it’s nicer when<strong> many people use the solution</strong>. When developing, we should bring <strong>as much value as possible</strong> to <strong>as</strong> <strong>many users as we can</strong>. Therefore, it is mandatory to ask the following questions:</p><ul><li><strong>Who</strong> is going to use the system/feature?</li><li>For <strong>how long</strong> they will be using it?</li><li>Is it in a<strong> specific season</strong>?</li></ul><p>Questions may vary depending on <strong>what’s being developed</strong>; a user may <strong>not necessarily need to interact</strong> with a system to “<strong>use</strong>” it; for instance, a calendar may track all my events, but I can accept it from my email.</p><h3>Scoring your features</h3><p>As Peter Drucker is ofter quoted “<strong><em>If you can’t measure it, you can’t manage it</em></strong><em>”</em>, it became relevant to provide a way of measure what we do. Personally, I like scales from [0, 10], but you can create your own one, with ranges depending on your scenario. It’s primordial to understand that each company may <strong>measure the 3U depending on their clients/users, level of impact and engineering skills</strong>. Having a product that reaches millions of people (like facebook), cannot be compare to one only used for a few companies like mining companies in a specific country.</p><h4>Measuring “Useful”</h4><p>As we already mentioned, we can measure usability on an impact scale; I presented a 3 levels but you an use more; nonetheless it still have to be transformed to a 10 score scale. For that, we can simply apply:</p><ol><li><strong>We will not eat if we do not have the feature 😅: </strong>score [8, 10]</li><li><strong>This will save so much time 🔥/ This is a game changer🤓: </strong>score [5, 7]</li><li><strong>This is cool 🙃/ Nice to have / In the future: </strong>score [1, 4]</li></ol><h4>Measuring “Usable”</h4><p>Measuring usable can be complicated because it depends on the skills, time and budget allocated to design (UX/UI and solution) the feature. Understanding any possible interaction or state that a system can have, its time consuming but it exponentially increase the result. As, it may have many ways of measuring it, we propose to use the process definition scale, skillsets / client satisfaction evaluation, depending on whether the feature will be develop or if it was already developed.</p><p>Example:</p><ol><li><strong>Have a strong and well defined process to design/evaluate a feature</strong>: [8, 10]</li><li><strong>Have it contemplated or we have someone who take care of it:</strong> [5, 7]</li><li><strong>It’s just UI:</strong> [1, 4 ]</li></ol><h4>Measuring “Used”</h4><p>Example:</p><ol><li><strong>Have / will have 100 active users or more:</strong> [8, 10]</li><li><strong>Have / will have from 50 upto 99 users:</strong> [4, 7]</li><li><strong>Have / will have upto 49 users: </strong>[1, 3]</li></ol><h3>Scoring example</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/850/1*eyNqcz6KcW7ZKJXivb82Ag.png" /><figcaption>3U score for a feature</figcaption></figure><h3>Final words</h3><p>Sometimes we also need to check the impact of <strong>having</strong> or <strong>not having</strong> the feature implemented on the business side, features like on boarding is something that is used once by each user but it allows to <strong>show early value to you client</strong>, which depending on the business phase, it may be more important that having a dashboard or a forgot password feature implemented.</p><p>Finally, I would recommend to add an Business Impact axis to the 3U to form a 3U-BI score model.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8fa59e7815e3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Running a chat message web-app with Kubernetes (Kubeadm, VMs, NodeJS, ReactJS and RabbitMQ) in a…]]></title>
            <link>https://medium.com/@eftech93/running-a-chat-message-web-app-with-kubernetes-kubeadm-vms-nodejs-reactjs-and-rabbitmq-in-a-d0d07f05edb8?source=rss-eda0dd494816------2</link>
            <guid isPermaLink="false">https://medium.com/p/d0d07f05edb8</guid>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[k8s]]></category>
            <category><![CDATA[rabbitmq]]></category>
            <dc:creator><![CDATA[Esteban Puello]]></dc:creator>
            <pubDate>Mon, 08 Jan 2024 18:23:03 GMT</pubDate>
            <atom:updated>2024-01-08T18:23:03.523Z</atom:updated>
            <content:encoded><![CDATA[<h3>Running a chat message web-app with Kubernetes (Kubeadm, VMs, NodeJS, ReactJS and RabbitMQ) in a local cluster</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*OTZ3xahH8QcRfcNqFiCBcg.png" /><figcaption>Tech stack</figcaption></figure><p>If you’ve ever wondered how to build a cool chat app that doesn’t just fall over when a bunch of people start using it, this article is for you. We’re diving into the world of web apps with a hands-on guide that’s all about setting up a chat message app. But we’re not just using any old tech; we’re talking about a powerhouse combo of Kubernetes, NodeJS, ReactJS, and RabbitMQ, all running in a local cluster.</p><p>Starting from scratch, we’ll walk you through setting up virtual machines (VMs) with Ubuntu, getting your hands dirty with Docker and Kubernetes, and hooking up all the pieces. It’s a step-by-step journey where you’ll learn how to manage a Kubernetes cluster like a pro, connect the front end with the back end, and make sure your messages fly through RabbitMQ without a hitch.</p><p>Convention:</p><ul><li>Frontend: FE</li><li>Backend: BE</li><li>A VM is a node in the cluster</li></ul><p>Step by step:</p><ol><li>Creating clusters VMs (ubuntu): download iso and install in OS, add network configurations (NAT network and bridged network),</li><li>Install dependencies in VMs: install docker, kubectl, kubeadm, kubelet, etc,</li><li>Deactivate swapoff,</li><li>Initialize Kubernetes cluster in master node,</li><li>Join worked node (VMs) to master node with token and certificate,</li><li>Install and configure UI dashboard (and user),</li><li>Download code on Master node,</li><li>Configure Docker Repository (optional),</li><li>Build docker images and push in repository (optional),</li><li>Apply YML configurations,</li><li>Update IPs on configurations,</li><li>Access your app in your LAN !</li></ol><p>Let’s start:</p><h3>First step — Install Virtual Box and Create VMs</h3><p>We are going to install Virtual Box (<a href="https://www.virtualbox.org/wiki/Linux_Downloads">https://www.virtualbox.org/wiki/Linux_Downloads</a>) and download the Ubuntu ISO for the VM (<a href="https://ubuntu.com/download/desktop">https://ubuntu.com/download/desktop</a>). You can use Ubuntu server, but for the this tutorial, we used Ubuntu Desktop.</p><p>For installing Ubuntu using the ISO, you can basically use the same guide as installing it on a normal PC (<a href="https://ubuntu.com/tutorials/install-ubuntu-desktop#1-overview">https://ubuntu.com/tutorials/install-ubuntu-desktop#1-overview</a>). Just make sure to restart instead of continue with the trial.</p><p>In your VMs configurations you should always prove at least 4 GB RAM and 25GB of space and 1 processor.</p><p>For my configuration, I provided 10 GB RAM, 3 processors and 50 GB of Disk. For my configuration, I had a Master VM and 3 Worker VMs (same specification for each).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/973/1*_jpE-fV7MfkChOzg8EbC3w.png" /></figure><p>Once your VMs are created we are going to open the settings and select network options, attach adapter 1 to NAT, and Adapter 2 to Bridged.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/962/1*FyAZle2Df5Dw4Lixi1sjlQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/962/1*pNURACxCgmdd_q-U7W42lQ.png" /><figcaption>Network Configuration.</figcaption></figure><blockquote>The NAT (Network Address Translation) Adapter is the simplest way of accessing an external network from a virtual machine (<a href="https://www.virtualbox.org/manual/ch06.html">https://www.virtualbox.org/manual/ch06.html</a>)</blockquote><blockquote>Virtual Box Uses a device driver on your <em>host</em> system that filters data from your physical network adapter… The host can send data to the guest through that interface and receive data from it. (<a href="https://docs.oracle.com/en/virtualization/virtualbox/6.0/user/network_bridged.html">https://docs.oracle.com/en/virtualization/virtualbox/6.0/user/network_bridged.html</a>)</blockquote><p>All of this means that the NAT adapter allows you to access internet without any issue and the Bridged adapter allows you to connect between the different VMs and the host without any issues.</p><p>To test that you can access each node from master to/from worker, use the ping command with the IP address of each VM.</p><h3>Second step — Install Docker and Kubernetes</h3><p>On each VM you will need to install docker and kubernetes</p><p>Install docker:</p><pre>sudo apt update &amp;&amp; sudo apt upgrade -y<br>sudo apt install -y docker.io<br>sudo systemctl enable docker<br>sudo systemctl start docker</pre><p>Install Kubernetes:</p><pre>sudo apt-get update<br>sudo apt-get install -y apt-transport-https ca-certificates curl gpg<br>curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.28/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg<br>echo &#39;deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.28/deb/ /&#39; | sudo tee /etc/apt/sources.list.d/kubernetes.list<br>sudo apt-get update<br>sudo apt-get install -y kubelet kubeadm kubectl<br>sudo apt-mark hold kubelet kubeadm kubectl</pre><p><strong>Note: </strong>apt-mark hold prevents package from being automatically installed, upgraded or removed.</p><h3>Third step — Deactivate swap</h3><p>Kubernetes does not support swap, so we need to deactivate it otherwise it’s not going to work.</p><blockquote>Swap space is the area on a hard disk. It is a part of your machine’s Virtual Memory, which is a combination of accessible physical memory (RAM) and the swap space. Swap holds memory pages that are temporarily inactive. Swap space is used when your operating system decides that it needs physical memory for active processes and the amount of available (unused) physical memory is insufficient. (<a href="https://help.ubuntu.com/community/SwapFaq">https://help.ubuntu.com/community/SwapFaq</a>)</blockquote><pre>sudo swapoff -a</pre><h3>Fourth step — Initialize cluster in Master VM</h3><p>In settings, look for the Network options and select the one with setting start by 192.168.X.X as you master VM IP. For My master VM is 192.168.2.46.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/973/1*MxfoF8WF8WrDbxJy-OhAhQ.png" /></figure><p>Then on you terminal run:</p><pre>sudo kubeadm init — pod-network-cidr=10.244.0.0/16 — apiserver-advertise-address=192.168.2.46</pre><p><strong>Note:</strong> Make sure to use your master IP instead of mine (XD).</p><p><strong><em>kubeadm init</em></strong> will provide (show on terminal) a command which you can use to join your worked nodes, it should look something like this:</p><pre>kubeadm join 192.168.2.46:6443 --token ul8nvx.8yerzstwygqtcc10 --discovery-token-ca-cert-hash sha256:888e70ea85ba37035a807c0e8d0463a9b95e8134d26c262fe0ccf1c917be5bc3</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/815/1*idvh1tFpzzY2KZCcsjiH3g.png" /></figure><p>Then make .kube folder and copy configuration in it.</p><pre>mkdir -p $HOME/.kube<br>sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config<br>sudo chown $(id -u):$(id -g) $HOME/.kube/config</pre><p>Install calico:</p><pre><br>kubectl create -f https://raw.githubusercontent.com/projectcalico/calico/v3.26.4/manifests/tigera-operator.yaml<br><br>kubectl create -f https://raw.githubusercontent.com/projectcalico/calico/v3.26.4/manifests/custom-resources.yaml</pre><p>After a moment your master node should look like:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TzHPtMPIp2o21amPLrGSZQ.png" /></figure><p>Restart kube-proxy (optional):</p><pre>kubectl get pods -n kube-system -l k8s-app=kube-proxy</pre><h3>Fifth step — Join worker nodes into master node</h3><p>On each worker VM, we are going to use the command given but the Master node, don’t forget to disable swap:</p><pre>sudo swapoff -a <br>kubeadm join 192.168.2.46:6443 --token ul8nvx.8yerzstwygqtcc10 --discovery-token-ca-cert-hash sha256:888e70ea85ba37035a807c0e8d0463a9b95e8134d26c262fe0ccf1c917be5bc3 –node-name worker-n</pre><p><strong>Note:</strong> change node-n for the name that you want your worker to have.</p><p><strong>Note:</strong> make sure that your hostname is different for each VM; to change it you can perform <em>hostname </em>to get your host name and <em>sudo open /etc/hostname </em>to open and modify its value. Then perform <em>sudo reboot. </em>If you run it (join command) before changing your hostname, you will need to restart the process by removing node from cluster, (kubectl drain node-name — ignoe-daemonsets — delete-emptydir-data &amp;&amp; kubectl delete node node-name), kubectl reset and join again.</p><p>After some time, on your Master VM, on the terminal use the command:</p><pre>kubectl get nodes</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Oc9iSdmo58r6peXkhv1GwQ.png" /></figure><h3>Sixth step — Install and configure dashboard on Master Node</h3><p>Install dashboard by:</p><pre>kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/v2.4.0/aio/deploy/recommended.yaml<br>kubectl create serviceaccount dashboard-admin -n kubernetes-dashboard<br>kubectl create clusterrolebinding dashboard-admin-binding --clusterrole=cluster-admin --serviceaccount=kubernetes-dashboard:dashboard-admin<br>kubectl -n kubernetes-dashboard create token dashboard-admin</pre><p>It should return a token like this:</p><pre>eyJhbGciOiJSUzI1NiIsImtpZCI6InpOYWhZaW5sTEN6YmZBUUgtc0owX2Z5aHJvNzNHQzRrM25nYUZyNXh6bW8ifQ.eyJhdWQiOlsiaHR0cHM6Ly9rdWJlcm5ldGVzLmRlZmF1bHQuc3ZjLmNsdXN0ZXIubG9jYWwiXSwiZXhwIjoxNzAwNDIzMzgxLCJpYXQiOjE3MDA0MTk3ODEsImlzcyI6Imh0dHBzOi8va3ViZXJuZXRlcy5kZWZhdWx0LnN2Yy5jbHVzdGVyLmxvY2FsIiwia3ViZXJuZXRlcy5pbyI6eyJuYW1lc3BhY2UiOiJrdWJlcm5ldGVzLWRhc2hib2FyZCIsInNlcnZpY2VhY2NvdW50Ijp7Im5hbWUiOiJkYXNoYm9hcmQtdXNlciIsInVpZCI6IjJlMWJkN2EzLWFhOTctNDYxMy05ODMyLTU4M2YzYzZhZDA3OSJ9fSwibmJmIjoxNzAwNDE5NzgxLCJzdWIiOiJzeXN0ZW06c2VydmljZWFjY291bnQ6a3ViZXJuZXRlcy1kYXNoYm9hcmQ6ZGFzaGJvYXJkLXVzZXIifQ.GshXiBfZnjV6cloN0Aw9O9gv3LzfHZwB6R__dSsc1Viogb7JE4TkcvcV3T8ETNwfB-DazxmvWisHbZmHH6jY-7K-Z1FITWucXDnjn0PewZlAkFV6v-3zdDSdCtb-PWMxETtUzZ7NPcat2jdfKOPfYx0Cac-mbUafR0Ztr6r2qzR8EvxK5qP9roQeeanksz8dC0GG-S52Yve2aAOi9GmEXo7Is1nzAmq8pbqdZBHJEV4UeLoPSK8az8n_SAlAXoMUJXk0jopvq9CteLHlPZeE6NBz6rkBteHoc_uhUkNd3rEgeQ0pM3w-3KJAp1WY0TiFUqYmUbv3hBk0OxXEaulsNw</pre><p>On terminal run:</p><pre>kubectl proxy</pre><p>It should launch a dashboard on the 127.0.0.1:8001</p><pre>http://localhost:8081api/api/v1/namespaces/kubernetes-dashboard/services/https:kubernetes-dashboard:/proxy/#/replicationcontroller?namespace=_all</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7k5_0jaFAzMLsPtH-SCgFA.png" /></figure><p>Select the token option and use the token generated on the create token command.</p><h3>Seventh step — Download code on Master node</h3><p>On your VM open your browser and download project from <a href="https://github.com/eftech93/post-kubernete-chat">https://github.com/eftech93/post-kubernete-chat</a> it contains 4 folders, backend, broker, deployment and frontend.</p><p>If you want to execute the FEand BE in local, you will need to install NodeJS in your machine. (optional)</p><h3>Eighth step — Configure Docker Repository (Optional)</h3><p>If you do not want to build your own docker image, you can skip this step and use the default docker image in the deployment folder (eftech93/chat-frontend and eftech93/chat-backend).</p><p>You can go and create an account on docker hub (<a href="https://hub.docker.com/">https://hub.docker.com/</a>) if you don’t have one. After you log in, you can create a new repository in you namespace</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*k0fhAo76pysFTg3qo-3RSA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OwV2a72JnHs8uYiQ4BP4rQ.png" /><figcaption>Create new repository in docker hub</figcaption></figure><p>On your VM terminal:</p><pre>sudo docker login</pre><p>It’s going to ask for your user name and your password, you can use a generated token or your actual password.</p><h3>Ninth step -Build docker images and push in repository (optional)</h3><p>In the terminal of you master VM, you can go to the folder backend and run:</p><pre>sudo docker build -t eftech93/chat-backend:latest .<br>sudo docker image push eftech93/chat-backend:latest</pre><p>it’s going to build the docker image under eftech93, you should replace it with your own repository and user name.</p><p>Then go to FE folder and run:</p><pre>sudo docker build -t eftech93/chat-frontend:latest .<br>sudo docker image push eftech93/chat-frontend:latest</pre><p>If you push your own docker image, you will need to modify the frontend.yml and backend.yml to set your own image.</p><h3>Tenth step — Apply YAML configurations</h3><p>Now, you can go to the folder deployment and run the following commands:</p><pre>kubectl apply -f ./config.yml<br>kubectl apply -f ./broker.yml<br>kubectl apply -f ./backend.yml<br>kubectl apply -f ./frontend.yml</pre><p>Now you can check the pods if they are running properly by running command:</p><pre>kubectl get pods -o wide</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3CuzLWed-jmIJK5aO_6Dew.png" /></figure><p>it’s going to show which container is running in which node!</p><h3>Eleventh step — Update configuration</h3><p>On your master terminal run:</p><pre>kubectl get svc</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N1cO-4WooLAYAi6Vu7cWUg.png" /></figure><p>In the folder deployment you can edit the config file by updating the BE domain from api.chat-test.com to your master vm ip and your backend-service NodePort. The port is around the 32000, in my case 192.168.2.46:30788. Once you apply the changes you can update the configmap by :</p><pre>kubectl apply -f ./config.yml</pre><p>Finally, you can restart your frontend pods by doing:</p><pre>kubectl rollout restart deployment chat-frontend</pre><p>Or you can manually delete each pod by:</p><pre>kubectl delete pod pod-name</pre><h3>Last Step — Enjoy!</h3><p>Now that you arrived here, you can use your master VM IP address and your FE PortNode port, to access the FE from any machine in your LAN!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tqwSZ39F083kvsSpjzZ5Tw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*JJBvaHOMdXOsdDRomYo05w.jpeg" /><figcaption>Accessing FE form PC and android phone</figcaption></figure><h3>Final words &amp; Next?</h3><p>This cluster configuration can have some issues with the proxy and calico, it my crash and restart many times. On the next tutorial, we will deploy our cluster on AWS or DigitalOcean and fix those issues.</p><p>Links &amp; References:</p><ul><li><a href="https://github.com/eftech93/post-kubernete-chat">GitHub - eftech93/post-kubernete-chat</a></li><li><a href="https://www.virtualbox.org/wiki/Linux_Downloads">Linux_Downloads - Oracle VirtualBox</a></li><li><a href="https://ubuntu.com/download/desktop">Download Ubuntu Desktop | Ubuntu</a></li><li><a href="https://ubuntu.com/tutorials/install-ubuntu-desktop#1-overview">Install Ubuntu Desktop | Ubuntu</a></li><li><a href="https://www.virtualbox.org/manual/ch06.html">Chapter 6. Virtual Networking</a></li><li><a href="https://docs.oracle.com/en/virtualization/virtualbox/6.0/user/network_bridged.html">6.5. Bridged Networking</a></li><li><a href="https://help.ubuntu.com/community/SwapFaq">SwapFaq</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d0d07f05edb8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Deploying a Chat Application in Minikube with Argo CD: A Comprehensive Guide]]></title>
            <link>https://medium.com/@eftech93/deploying-a-chat-application-in-minikube-with-argo-cd-a-comprehensive-guide-a7e252fc38a0?source=rss-eda0dd494816------2</link>
            <guid isPermaLink="false">https://medium.com/p/a7e252fc38a0</guid>
            <category><![CDATA[argo-cd]]></category>
            <category><![CDATA[tutorial]]></category>
            <category><![CDATA[minikube]]></category>
            <category><![CDATA[chat]]></category>
            <dc:creator><![CDATA[Esteban Puello]]></dc:creator>
            <pubDate>Thu, 04 Jan 2024 01:48:07 GMT</pubDate>
            <atom:updated>2024-01-04T03:47:37.818Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*StyYBLsJwkjSe8Wh4UaTVQ.png" /></figure><p>In the evolving landscape of software development, containerization and Kubernetes have become integral for deploying applications. This guide walks you through the process of setting up a chat application in Minikube using Argo CD, a tool that allows for continuous deployment using GitOps principles. Minikube provides a local Kubernetes environment, making it an ideal platform for testing and development.</p><p>Steps for this tutorial:</p><ol><li>Enable ingress in minikube</li><li>Apply configurations of chat</li><li>Update /etc/hosts on your machine</li><li>Enable minikubetunnel</li></ol><h3>1. Enable ingress in Minikube</h3><p>Let’s begin by enabling necessary addons in Minikube. These include ingress and ingress-dns. These addons enhance Minikube’s capabilities, allowing it to handle network ingress. Run the following commands:</p><pre>minikube addons enable ingress<br>minikube addons enable ingress-dns</pre><p>This will take some time…</p><h3>2. Apply configurations of chat</h3><p>Deploy your chat application in the Kubernetes cluster by applying the necessary configurations. Use the following command to apply a predefined YAML configuration file:</p><pre>kubectl apply -f &quot;https://raw.githubusercontent.com/eftech93/post-argo-cd/main/chat-application.yaml&quot;</pre><p>Raw file looks like:</p><pre>apiVersion: argoproj.io/v1alpha1<br>kind: Application<br>metadata:<br>  name: chat<br>  namespace: argocd<br>spec:<br>  destination:<br>    namespace: chat<br>    server: &quot;https://kubernetes.default.svc&quot;<br>  project: default<br>  source:<br>    path: deployment<br>    repoURL: &quot;https://github.com/eftech93/post-kubernete-chat.git&quot;<br>    targetRevision: argocd<br>  syncPolicy:<br>    syncOptions:<br>      - CreateNamespace=true</pre><p>As you can see, we define a project default, with a workspace chat and a github repository to take the kubernetes configuration from (also a target branch — argocd-).</p><p>On your ArgoCD UI, you should see something like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RPvR68nn5kq6teHNUbfILw.png" /><figcaption>Chat project before sync</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vqY58J8GpgAFbaSE8UaKTA.png" /><figcaption>Resources out of sync</figcaption></figure><p>Then you can sync the resources of your project by clicking on Sync, and selecting all resources</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*P9pln_KU79sAbEj3J9H-kg.png" /></figure><h3>3. Update /etc/hosts on Your Machine</h3><p>Modify your system’s host file to route traffic for the chat application. This involves adding entries to direct the specified domain to your local machine. Add the following lines to your /etc/hosts file:</p><pre>127.0.0.1 api.chat-test.com<br>127.0.0.1 chat-test.com</pre><p>It should look something like:</p><pre>##<br># Host Database<br>#<br># localhost is used to configure the loopback interface<br># when the system is booting.  Do not change this entry.<br>##<br>127.0.0.1 localhost<br>255.255.255.255 broadcasthost<br>::1             localhost<br>127.0.0.1 api.chat-test.com<br>127.0.0.1 chat-test.com<br># Added by Docker Desktop<br># To allow the same kube context to work on the host and the container:<br>127.0.0.1 kubernetes.docker.internal<br># End of section</pre><h3>4. Enable minikube tunnel</h3><p>To expose external services running in Minikube, use the minikube tunnel command. This creates a network route on your host to the services deployed in Minikube:</p><pre>minikube tunnel</pre><p>In this way, you chat-test.com will be linked to you cluster on 127.0.0.1.</p><p><strong>note:</strong> do not close the terminal after calling minikube tunnel.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CAwiTFdyYwG5Z7YkT5cdFg.png" /><figcaption>Chat Application resources</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4i2j7QoWAVRP04bD6Q0lzg.png" /><figcaption>Sync option after everything is up to date.</figcaption></figure><h3>5. Enjoy!</h3><p>Go to chat-test.com and you should be able to see access the chat frontend.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3q4vlA7yBoAtgsaijHXV1A.png" /></figure><p><strong>Note: </strong>in my next tutorials, I will explain how the application works! and how to deploy it on a cluster in Digital Ocean.</p><p><strong>Note:</strong> in this tutorial you won’t be able to share it with your friends but wait for the next one</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a7e252fc38a0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Installing Argo CD on Minikube — GitOps with Argo CD]]></title>
            <link>https://medium.com/@eftech93/installing-argo-cd-on-minikube-gitops-with-argo-cd-c451d4a06459?source=rss-eda0dd494816------2</link>
            <guid isPermaLink="false">https://medium.com/p/c451d4a06459</guid>
            <category><![CDATA[minikube]]></category>
            <category><![CDATA[argo-cd]]></category>
            <category><![CDATA[tutorial]]></category>
            <category><![CDATA[gitops]]></category>
            <dc:creator><![CDATA[Esteban Puello]]></dc:creator>
            <pubDate>Wed, 27 Dec 2023 16:43:33 GMT</pubDate>
            <atom:updated>2023-12-27T16:43:33.986Z</atom:updated>
            <content:encoded><![CDATA[<h3>Installing Argo CD on Minikube — GitOps with Argo CD</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/850/1*97dEVD8mZaPzPqUFovZ77A.png" /><figcaption>Argo CD + Minikube</figcaption></figure><p>Before diving into the installation of Argo CD on Minikube, it’s crucial to understand what ArgoCD and GitOps are. ArgoCD is an open-source tool designed for Kubernetes to implement GitOps practices. GitOps is a methodology that uses Git as a single source of truth for declarative infrastructure and applications. With GitOps, all changes are made through code commits, making it easier to manage and version control infrastructure and applications.</p><p>ArgoCD extends this by providing a way to automatically apply and synchronize these changes in Kubernetes environments. It allows developers to manage the deployment and lifecycle of applications in a Kubernetes cluster using Git repositories as the source of truth. This way, ArgoCD facilitates continuous deployment and monitoring, aligning with the principles of GitOps.</p><p>Steps for this tutorial:</p><ol><li>Download &amp; Install minikube</li><li>Get all running pods (optional)</li><li>Create namespace for argocd</li><li>Install argo CD No-HA way</li><li>Verify Argo CD Components are running</li><li>Retrieve Admin Credentials</li><li>Access Argo CD UI on Localhost</li><li>Install Argo CLI</li></ol><h3>1. Download &amp; Installing minikube:</h3><p>To install minikube we can perform (This step can take around 2 to 5 mins approx.):</p><pre>curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-darwin-amd64<br>sudo install minikube-darwin-amd64 /usr/local/bin/minikube</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A-OK7heehrOZyyLcl3GnAQ.png" /><figcaption>Minikube installation on a MacBook Pro M1</figcaption></figure><p><strong><em>Note:</em></strong> For non-Mac users, refer to the Minikube installation guide specific to your operating system (here <a href="https://minikube.sigs.k8s.io/docs/start/"><em>https://minikube.sigs.k8s.io/docs/start/</em></a><em>).</em></p><h3>2. Get all running pods</h3><p>Optionally, check all running pods in your Kubernetes environment using the command:</p><pre>kubectl get pods --all-namespaces</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HsaZ6RW01Krh0DgJg8rmkg.png" /><figcaption>All Pods in cluster</figcaption></figure><h3>3. Create namespace for argocd</h3><p>Set up a dedicated namespace for ArgoCD in your Kubernetes cluster with the following command (this will allow to differentiate resources within you “cluster”):</p><pre>kubectl create ns argocd</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1pfG0olhmVhykMctB0pQdg.png" /><figcaption>Create namespace for ArgoCD</figcaption></figure><h3>4. Install argoCD in cluster</h3><p>Install Argo CD using the command below. This will apply the necessary configurations from the official Argo CD repository:</p><pre>kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml</pre><p>It will look something like:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YQAv_JzvDH3iKtu_OgV_2A.png" /><figcaption>ArgoCD installation in minikube cluster</figcaption></figure><h3>5. Verify Argo CD Components</h3><p>Ensure that all Argo CD components are running correctly in the namespace by using:</p><pre>kubectl get pods -n argocd</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*grdzK0m-ZQ5Kods9D3guig.png" /><figcaption>Pods on argocd namespace</figcaption></figure><h3>6. Retrieve Admin Credentials</h3><p>Obtain the admin password for Argo CD with the following command:</p><pre>kubectl get secret -n argocd argocd-initial-admin-secret -o yaml</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*si2tbTG1w-ug_njutwhF3g.png" /><figcaption>Admin secret for argo cd</figcaption></figure><p>Then decode it with usgin base64, with my encoded password: <em>T2dIaGdZb2pjQUV3WVk2Sg== , </em>you should get something like this: <em>OgHhgYojcAEwYY6J .</em></p><h3>7. Access Argo CD UI on Localhost</h3><p>Forward a local port to the Argo CD server to access the UI on your local machine. For example:</p><pre>kubectl port-forward svc/argocd-server -n argocd 8082:443</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Vg6zyX2cRcHKOccYhJ2YJw.png" /><figcaption>Forward from 8082 to 443</figcaption></figure><p>Now on your preferred browser look for localhost:8082, a page like thi8s should be displayed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Um_Kl_rAY-XvoK_Cm6L6Aw.png" /><figcaption>Log in page for argo cd</figcaption></figure><p>Use the username admin and the decoded password from previous steps and you should get something like:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qFhqrVN4e0nN_5Rwjkqg1g.png" /><figcaption>Initial state for argo CD</figcaption></figure><h3>8. Install Argo CLI</h3><p>To interact with Argo CD from your terminal, install the Argo CD CLI. For Mac M1 users, the installation commands are:</p><pre>VERSION=$(curl --silent &quot;https://api.github.com/repos/argoproj/argo-cd/releases/latest&quot; | grep &#39;&quot;tag_name&quot;&#39; | sed -E &#39;s/.*&quot;([^&quot;]+)&quot;.*/\1/&#39;)<br><br>curl -sSL -o argocd-darwin-arm64 https://github.com/argoproj/argo-cd/releases/download/$VERSION/argocd-darwin-arm64<br><br>sudo install -m 555 argocd-darwin-arm64 /usr/local/bin/argocd<br>rm argocd-darwin-arm64</pre><p>Note: For different operating systems, refer to the appropriate installation guide. (here: <a href="https://argo-cd.readthedocs.io/en/stable/cli_installation/"><em>https://argo-cd.readthedocs.io/en/stable/cli_installation/</em></a><em>)</em></p><p>Following these steps, you are now set to begin deploying applications on your Minikube cluster using Argo CD, marking your first steps into the world of GitOps!</p><p>On the next tutorial, we will run an application on minikube deployed by ArgoCD.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c451d4a06459" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>