<?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 Colin Domoney on Medium]]></title>
        <description><![CDATA[Stories by Colin Domoney on Medium]]></description>
        <link>https://medium.com/@colin.domoney?source=rss-1fbc617e4674------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*6srHTmK26Rq7K6-4oH9rgA.jpeg</url>
            <title>Stories by Colin Domoney on Medium</title>
            <link>https://medium.com/@colin.domoney?source=rss-1fbc617e4674------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 17:17:03 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@colin.domoney/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[Local Build Agents for Azure DevOps]]></title>
            <link>https://medium.com/@colin.domoney/local-build-agents-for-azure-devops-50e6046f87ea?source=rss-1fbc617e4674------2</link>
            <guid isPermaLink="false">https://medium.com/p/50e6046f87ea</guid>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[azure-devops]]></category>
            <category><![CDATA[azure]]></category>
            <category><![CDATA[appsec]]></category>
            <dc:creator><![CDATA[Colin Domoney]]></dc:creator>
            <pubDate>Mon, 13 May 2019 12:30:57 GMT</pubDate>
            <atom:updated>2019-05-13T12:30:57.376Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OUyWoJ7PfTlcT9_lLTU1bQ.png" /></figure><blockquote>Why you would even want to do this, and the things that will trip you up</blockquote><h4>A primer in Azure DevOps build agent technology</h4><p>Azure DevOps Pipelines is a cloud-hosted technology to allow CI (continuous integration) and CD (continuous deployment) software tasks to be executed in a coordinated fashion (using, for example, YAML configuration) when triggered by events in the lifecycle of the application (for example a successful merge request). The heavy lifting of executing the pipeline tasks such as compilation, packaging, etc. is performed by a <em>build agent </em>(also known as a <em>runner</em>).</p><p>Since the execution of a build agent task incurs compute cycles there is a hosting cost associated with build agent activity and this is one of the restrictions placed by Microsoft on concurrent execution; on the free version of Azure DevOps, only one concurrent build agent task may execute.</p><p>Internally on Azure DevOps, the build agents are decoupled from the core Azure DevOps fabric by an (undocumented) API. This allows build agents to be hosted internally on Azure DevOps itself (the built-in Hosted agent pools), on other cloud compute resource or indeed on local compute instances such as a VM or a bare-metal machine.</p><h4>Benefits of a local build agent</h4><p>The immediate question arises as to why you would want to run your own build agent and simply not pay for addition concurrent Microsoft Azure DevOps agents. The initial consideration is one of cost: it may be that you are able to provide compute resource at a lower cost than that bundled by Azure DevOps and you simply want to use Azure DevOps Pipelines as the orchestrator and you will supply the compute power. That’s perfectly fine, all you have to do is purchase additional agent pool counts via Azure DevOps.</p><p>The other two reasons relate to performance and are the reasons I initially investigated the local build agent capability.</p><ul><li><strong>Queuing time:</strong> My observation was that frequently I received a message about waiting for agent pool allocation while waiting for a build to commence despite not having any other tasks executing. This is a simple consequence of using a pool resource and not having a guaranteed allocation of agents. Although the delays were never lengthy (up to a minute or two) they were an annoyance when trying to accomplish rapid turnarounds on debug cycles (my YAML sometimes lets me down).</li><li><strong>(Lack of) Caching:</strong> A key tenet of building robust pipelines is that of zero assumptions about the pipeline environment (the so-called hermetic pipeline); all pre-requisites and tools should be installed as part of the pipeline setup process. This is perfectly understandable since on Azure DevOps Pipelines a build agent is provision on-demand for a job and is not dedicated to a particular pipeline, project or customer. However, this results in a large overhead of seemingly repetitive installation of tools. Having a dedicated local agent allows for the caching of tools since the agent context persists between invocations (the agent tool cache is stored to the local agent working folder). For large installations (like a kernel compilation) such a cache can result in significant time savings.</li></ul><p>These two advantages, although seemingly negligible, can produce significantly faster turnarounds on iterative builds; and are covered in more detail in the <a href="https://docs.microsoft.com/en-gb/azure/devops/pipelines/agents/agents?view=azure-devops#capabilities">FAQ</a> on the Azure DevOps build agent documentation.</p><h4>Installing the local build agent</h4><p>The installation of the built agent is very well documented and proved to be trivial on both Ubuntu 18.04LTS and MacOS Mojave 10.14.4. The process is documented in here for <a href="https://docs.microsoft.com/en-gb/azure/devops/pipelines/agents/v2-linux?view=azure-devops">Ubuntu</a> and here for <a href="https://docs.microsoft.com/en-gb/azure/devops/pipelines/agents/v2-osx?view=azure-devops">MacOS</a>. The only minor issues I had were with the correct folder ownership for the agent folders and assigning the agent to the Docker group to allow usage of Docker.</p><p>I assigned the agents to the ‘Default’ pool (I could have perhaps created a custom pool) and on the ‘Agent Pool’ tab was immediately able to see the installed agent and the fact that this was online and ready for scheduling.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/586/1*TytEMTpytc3ekh8eZEAkfA.png" /></figure><p>On the Ubuntu host, I installed the agent as a service to ensure that it would automatically start on reboot; on my Mac I simply run the service manually on demand.</p><h4>Installing custom tools on your agent</h4><p>Whilst the installation of the agent was a simple process the next step proved particularly troublesome to resolve; namely the installation of toolchains onto the agents. By default, a fresh install of an agent contains no tools at all and can only offer those of the host operating system. Microsoft has sought to address this problem by providing a feature called ‘tool installers’ which allows various tool dependencies to be installed on demand from within a pipeline task; these are documented <a href="https://github.com/Microsoft/azure-pipelines-tool-lib">here</a> and available on GitHub <a href="https://github.com/microsoft/azure-pipelines-tool-lib/blob/master/docs/overview.md">here</a>.</p><p>The use of the tool installer is simple to use as shown below; here a requirement on Node 11.13 is explicitly inserted as the first step in the pipeline.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/790/1*N_KZfsOBdytME7lxRnmB3Q.png" /><figcaption>Installing a specific Node</figcaption></figure><p>As soon as the pipeline is invoked a local tools cache is created in a subfolder on the agent named <em>_work/_tool</em>. Examing the folder shows the existence of a Node installed folder as shown:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/410/1*oALBqq8OWyhYZHB-tcLClA.png" /></figure><p>On subsequent executions, the tool installer will use the cached tool without re-installing it.</p><h4>Challenges with Python in particular</h4><p>Although the tools installer capability of Azure DevOps Pipelines allowed me to install an appropriate version of Node easily enough the same was not true when I came to install Python. I specified a requirement on Python 3.6.5 as shown below; however, this was never installed in the same way that Node was earlier.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/789/1*_BfH_CM8MF-bp77N1aJzTw.png" /><figcaption>Installing a specific Python</figcaption></figure><p>It appeared that the tool installer behaves differently for Python than for Node which was somewhat frustrating. A search of Google <a href="https://github.com/MicrosoftDocs/vsts-docs/issues/3514">revealed</a> I was not the only person to have struggled with this topic.</p><p>I decided to install Python from source directly into the <em>_tool </em>folder using instructions <a href="https://help.dreamhost.com/hc/en-us/articles/115000702772-Installing-a-custom-version-of-Python-3">here</a>; the important detail is to specify the--prefix option to avoid overwriting a machine installation! Doing an installation resulted in the output within the <em>_work/_tool</em> folder below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*HojA7Ipx6l_Hv5PLijY4Bw.png" /><figcaption>Tool folder initial install</figcaption></figure><p>I tested the installation from the install folder on the agent and confirmed that version 3.6.5 was invoked as expected. However when I attempted to use said version in a pipeline (by using -python -V ) I was disappointed to find that the Python invoked was the system Python 2.7 — certainly not the desired outcome!</p><p>Some searching and debugging revealed another little missing trick: it is necessary to create a ‘marker’ folder called ‘x64.complete’ in the root of the Python folder as shown below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*6QAHGWOkEklj-t-OZVCG6A.png" /><figcaption>Tool folder with the marker folder</figcaption></figure><p>After creating the directory I could confirm that python3 -V reported version 3.6.5; however, python -V still reported 2.7. The solution was simple — in the <em>bin</em> folder create a symlink from <em>python</em> to the <em>python3 </em>executable as shown:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/366/1*X2SynRanjdJ-08xlMvxi5w.png" /><figcaption>Symlink to python3</figcaption></figure><p>Finally testing this within a pipeline as shown reported version 3.6.5. as expected. Job done!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/713/1*a_I_gWMQtQzLPpotO7TgOQ.png" /><figcaption>Testing the Python version</figcaption></figure><p>One footnote on building Python from source: on MacOS Mojave I was unable to get a successful build despite much hacking and tweaking and Googling. I gave up building from source and simply ‘cloned’ my Python folder from my <a href="https://brew.sh/">Brew</a> cellar location. Although crude this worked perfectly.</p><h4>The further possibilities of running locally</h4><p>One unintended consequence of running an agent locally is that given sufficient permissions it is possible for the build agent to access local system resources. In my case, I wanted to use a USB serial port programmer to re-Flash a <a href="https://www.nodemcu.com/index_en.html">Node MCU</a> image onto an <a href="https://www.espressif.com/en/products/hardware/esp8266ex/overview">ESP8266</a> board and I was able to use a Bash script from within a pipeline task to directly access the programmer and perform the operation. Quite a neat little abuse of a so-called cloud-hosted solution!</p><h4>What next for build agents?</h4><p>This article has hopefully inspired you to go out and set up your own local build agents so you can leverage the benefits of low-latency builds (minimal queuing) and cached environments (avoid unnecessary re-installation of tools). There are some obstacles to be overcome to get a fully working solution but once you know how it’s a simple process.</p><p>Microsoft is in the process of further simplifying the task of installing build agents by releasing publically the container images which they themselves host on the Azure platform so rather than needing to install an agent on bare-metal it is possible to run a container. Further information on this can be found <a href="https://hub.docker.com/_/microsoft-azure-pipelines-vsts-agent">Docker Hub</a> and on <a href="https://github.com/microsoft/vsts-agent-docker">GitHub</a>.</p><h4>Learn even more</h4><p>If you’d like to learn more about Azure DevOps and specifically the security aspects thereof please be sure to view my recent <a href="https://www.veracode.com/">Veracode</a> <a href="https://www.brighttalk.com/webcast/12807/355812?utm_campaign=knowledge-feed&amp;utm_source=brighttalk-portal&amp;utm_medium=web">webinar</a> on the topic of <a href="https://www.brighttalk.com/webcast/12807/355812#utm_source=Colin%20Medium%20Post">“Securing the Sugar out of Azure DevOps”</a>.</p><p>The other top resource for finding out more about all things Azure is the fantastic <a href="https://developer.microsoft.com/en-us/advocates/index.html">cloud advocates</a>; they’re global and cover all aspects of getting going with Azure.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rXzpE8QNyFKcW4XhyTyrgw.png" /><figcaption>Azure</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=50e6046f87ea" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Reasons to Hate Tkinter — part 1 of n]]></title>
            <link>https://medium.com/@colin.domoney/reasons-to-hate-tkinter-part-1-of-n-37728229b600?source=rss-1fbc617e4674------2</link>
            <guid isPermaLink="false">https://medium.com/p/37728229b600</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[tkinter]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Colin Domoney]]></dc:creator>
            <pubDate>Thu, 04 Oct 2018 12:24:30 GMT</pubDate>
            <atom:updated>2018-10-04T12:24:30.937Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/414/1*3JBxsfc-1h-H_5ronrVaYg.png" /><figcaption>Behold the Wonder</figcaption></figure><h3>Reasons to Hate Tkinter — part 1 of n</h3><h3>How Hard Can It Be?</h3><p>The task was a simple one: create a Tkinter GUI to process incoming data packets from a socket connection and render them to a panel. That’s it! Given my Python is more than a little rusty I figured this would probably take a day or so of work. How wrong I was …</p><h3>Why Tkinter?</h3><p>I’d thought about using some kind of crude mechanism to throw up an HTML5 canvas based on some discussions <a href="https://stackoverflow.com/questions/1413540/showing-an-image-from-console-in-python">here</a>, and investigated a couple of options <a href="https://www.pyimagesearch.com/2016/12/19/install-opencv-3-on-macos-with-homebrew-the-easy-way/">here</a> and <a href="https://github.com/adicu/pantograph">here</a>. Given I was already using the awesome <a href="https://python-pillow.org/">PIL</a> graphics library I was delighted to find that PIL supported Tkinter as per discussion <a href="https://stackoverflow.com/questions/18369936/how-to-open-pil-image-in-tkinter-on-canvas">here</a> — in fact there is a dedicated <a href="http://effbot.org/tkinterbook/photoimage.htm">Tkinter display library</a> built into PIL. Plus Tkinter is ubiquitous, it’s been around for years and everyone knows how to use it …</p><h3>Just Add a Thread …</h3><p>Due to the nature of my application, I need to be continuously listening on a socket connection for incoming data and of course, the best way to wait on long-running asynchronous tasks is to use a listening thread. This is a well-understood problem and a review of <a href="https://stackoverflow.com/questions/16745507/tkinter-how-to-use-threads-to-preventing-main-event-loop-from-freezing">StackOverflow</a> convinced me this was trivially accomplished by using a class derived from a threading.Thread class. Simply override the run() method and remember to gracefully abort the thread closing the socket and it should just work. And it did … most of the time.</p><h3>How Long Can It Take to Convert a 28x38 Pixel Image?</h3><p>I implement a bit of code in the receiving thread to convert the incoming raw data (from a PIL tobytes() dump) into a PIL image using the <a href="http://effbot.org/tkinterbook/photoimage.htm">Tkinter.PhotoImage</a> class. It virtually worked the very first time around and even the slightly puzzling “disappearing image problem” had a <a href="http://effbot.org/pyfaq/why-do-my-tkinter-images-not-appear.htm">trivial fix</a>. Whilst testing the application I noticed that occasionally an image would be lost due to buffer overrun on the receiver side so I naturally increased the buffer size but ever after a 16kB buffer didn’t solve the problem I began to suspect something else like a deadlock. The GUI (such as it is) remained responsive so where was the time going? After all the code was only pulling in a buffer, converting it to a PIL image and inserting it into a canvas. I tried some of the usual tricks by putting critical region locks around the thread code until the entire thread was locked down! Still I dropped frame.</p><h3>Enter the Fantastic <a href="https://github.com/mherrmann/timer-cm">timer_cm</a> Tool</h3><p>Because the thread was ‘real time’ stepping it with a debugger was useless, I needed to see in realtime where the time was going. I stumbled across <a href="https://github.com/mherrmann/timer-cm">timer_cm</a> and tried it to time the code blocks in my thread. The usage is almost trivial, for example:</p><pre><strong>from </strong>timer_cm <strong>import *<br>import </strong>os, sys, time<br><br><strong>def demo_performance_timer():<br><br>    with </strong>Timer<strong>(&#39;main timer&#39;) as </strong>tm<strong>:<br>        with </strong>tm.child<strong>(&#39;short subtask&#39;):<br>            </strong>print<strong>(&quot;I&#39;m super quick !&quot;)<br>        with </strong>tm.child<strong>(&#39;medium subtask&#39;):<br>            </strong>time.sleep<strong>(</strong>0.5<strong>)<br>            </strong>print<strong>(&#39;Half a second, give or take&#39;)<br>        with </strong>tm.child<strong>(&#39;long subtask&#39;):<br>            for </strong>i <strong>in </strong>range<strong>(</strong>10000<strong>):<br>                for </strong>j <strong>in </strong>range<strong>(</strong>5000<strong>):<br>                    </strong>x <strong>= (</strong>i<strong>*</strong>j<strong>)<br>            </strong>print<strong>(&#39;Phew all done!&#39;)<br><br><br>if </strong>__name__ <strong>== &#39;__main__&#39;:<br>    </strong>demo_performance_timer<strong>()</strong></pre><p>This gives the following output:</p><pre>I’m super quick !<br>Half a second, give or take<br>Phew all done!<br>main timer: 3.544s<br> long subtask: 3.041s (85%)<br> medium subtask: 0.503s (14%)<br> short subtask: 0.000s (0%)</pre><p>It’s really quite that simple: you get the roll-up time for the entire block, and for individual children blocks. I’m hugely thankful to <a href="http://www.herrmann.io/">Michael Herrmann</a> for this fantastic little library.</p><p>I immediately isolated the problem: when the frame loss occurred I could see that a single call to ImageTk.PhotoImage() was taking a long time … normally it would complete in a few milliseconds but sometimes it took a few seconds and the worst case I saw was a whopping 20 seconds. We’re going to need a much bigger buffer!</p><h3>Handling Rendering in the Tkinter Idle Loop</h3><p>GUI frameworks have a fine tradition of not being amenable to update the UI on threads other than that on which the application message look was invoked; in C# an exception occurs. The usual approach is to either render the image from the main loop idle loop, use a lock in the thread or post a message back to the main thread. Given I’d eliminated the lock option I looked for ways to use an idle loop or a message. Amazingly Tkinter supports neither! <a href="http://stupidpythonideas.blogspot.com/2013/10/why-your-gui-app-freezes.html">This</a> was the best expose on the topic, and perhaps ‘<a href="https://www.reddit.com/r/Python/comments/7rp4xj/threading_a_tkinter_gui_is_hell_my_least_favorite/">Threading a TkInter GUI is Hell</a>’ best summarises my views on the topic. Basically, the solution is to use the .after(timeout, handler) method to periodically call a polling function that checks if there is a new image and then safely renders that. The catch is the timeout — making it too long will mean a lag in the display, too short will mean all the CPU time is burnt needlessly polling. For a video display such as this 25ms seemed ideal. Lo and behold implementing this one little trick produced a Tkinter application that rendered almost perfect real-time video display. And in only a little over 24 hours of work.</p><p>Next time I want to use Tkinter for something … I won’t.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=37728229b600" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Containers — my favourite bits]]></title>
            <link>https://medium.com/@colin.domoney/containers-my-favourite-bits-41f6b7f57a99?source=rss-1fbc617e4674------2</link>
            <guid isPermaLink="false">https://medium.com/p/41f6b7f57a99</guid>
            <category><![CDATA[virtual-machine]]></category>
            <category><![CDATA[containers]]></category>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[Colin Domoney]]></dc:creator>
            <pubDate>Mon, 02 Apr 2018 10:01:48 GMT</pubDate>
            <atom:updated>2018-04-02T10:01:48.405Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/449/1*Nr4aTD-yeRTRLTmv3rjbIQ.png" /><figcaption>Developers love containers … and writing tests …</figcaption></figure><h3>Speed</h3><h4>Embedded Hell</h4><p>I started my career as an embedded systems engineer designing telecommunications kit based on the Intel <a href="https://en.wikipedia.org/wiki/Intel_80386EX">80386EX</a>. The absolute bane of my existence was having to wait for the EEPROM erase cycle to finish so you could try your new code. Fortunately Flash memory changed this dramatically, and I always took great pains to ensure that my development environment was optimised around rapid ‘flash-and-debug’ cycles — anything more than 30 seconds was too long for me.</p><h4>JIT, MSIL, JVMs, etc</h4><p>When I started developing on PCs I loved the quick turnarounds possible particularly as the bytecode languages with their JIT compilation meant almost instantaneous debug cycles. What I enjoyed a lot less was constantly having to install a host of support libraries and frameworks to get my applications to work only to discover that I had then rendered MS Word inoperable due to some DLL incompatibility. Similar switching between projects with different toolchains was fraught with danger due to the shared runtime and filesystems. Much of the speed advantage of the new languages was offset by the context switch associated with their environments.</p><h4>Virtual Machines</h4><p>This heralded the era of virtual machines and the free <a href="https://www.vmware.com/uk/products/workstation-player.html">VMWare Player</a> product meant one could keep entirely isolated environments and indeed entire OS’s for different projects. However VM’s are slow to boot, require heavy host resources and have to be configured before use (although tools such as <a href="https://www.vagrantup.com/">Vagrant</a> ease this task).</p><h4>Enter the Age of Containers</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/635/1*0-Wd-gHp7pk2ZrSIK3WLqQ.png" /></figure><p>The first time I ran the canonical Docker ‘<a href="https://hub.docker.com/_/hello-world/">hello-world</a>’ example I was convinced something was wrong with my setup because surely <strong>nothing</strong> was going to run in just over a second? As a developer with a ‘need for speed’ I love the whole user experience of being able to do fast turnarounds on the debug cycle. Want to try something quickly — just hack it into the image, run it and test. Didn’t work? Just drop back to the previous image. No longer to I have to worry about having destroyed my host operating system as well — <strong>rollback</strong> is almost trivial.</p><h3>Ubiquity of Images</h3><p>One of the drawbacks of VM’s was the ceremony involved in creating an image that fulfilled all your requirements; certainly it was possible to download pre-canned images for popular OS’s but if you wanted to try out shiny new thing <em>xyz</em> you probably had to step through a number of hoops to get the dependencies installed and everything configured correctly.</p><p>With Docker’s <a href="https://hub.docker.com/">DockerHub</a> there are literally hundreds of thousands of ready-made images to meet your every need, and if your new shiny thing doesn’t have an image there you can bet someone’s making one to put on GitHub.</p><p>This all but removes the barrier to entry to learn or sample a piece of new technology.</p><h3>Build Once, Run Anywhere</h3><p>“But it runs fine on my machine” is one of the oft quoted defences when a developer’s new feature doesn’t work on production or QA as expected. In as much as an embedded system’s firmware depended on its host hardware so a modern application depends on it’s host OS and environment. Traditionally it has been hard to encapsulate state of a developer’s ‘golden machine’ and reproduce it with fidelity downstream. Now it’s as simple as shipping a Docker file with your software — it really is immutable infrastructure as code.</p><h3>Orchestration Awesomeness</h3><p>Containers set out to make the task of providing infrastructure as simple as possible, and the task of orchestration (via <a href="https://docs.docker.com/engine/swarm/#feature-highlights">Swarm</a>, Kubenetes, et al) is to build on this simplicity and provide an extra tier of features such as:</p><ul><li>Desired state reconciliation : simply specify your target environment as a manifest and rely on your orchestrator to make it (and keep it) so.</li><li>Scaling: Need more app servers? Just tweak a value in your swarm config and update; no need to build any new infrastructure.</li><li>Rolling updates: Want to update your application? Use rolling updates to do a staggered, staged update to avoid your application being taken entirely offline during an update.</li><li>Declarative syntax: express your target infrastructure as code.</li></ul><h3>The Community</h3><p>Containers and their associated menagerie present a significant learning curve to the new user. As a new user to containers I found the learning experience and community engagement second to none: from many excellent <a href="https://app.pluralsight.com/paths/skills/docker">online courses</a>, to Kelsey Hightower’s many <a href="https://www.youtube.com/watch?v=a1VDS-8TBX0">fantastic presentations</a>, to many excellent free and <a href="https://github.com/rancher">open source tools</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=41f6b7f57a99" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>