<?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 Steve on Medium]]></title>
        <description><![CDATA[Stories by Steve on Medium]]></description>
        <link>https://medium.com/@steve_76519?source=rss-b06f5ef02d66------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*wWsLQBN1pSzLqV5r</url>
            <title>Stories by Steve on Medium</title>
            <link>https://medium.com/@steve_76519?source=rss-b06f5ef02d66------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 12:41:58 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@steve_76519/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[How to Quantify the ROI of Platform Engineering]]></title>
            <link>https://medium.com/napptive/how-to-quantify-the-roi-of-platform-engineering-e533a660a0fd?source=rss-b06f5ef02d66------2</link>
            <guid isPermaLink="false">https://medium.com/p/e533a660a0fd</guid>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[cloud-native]]></category>
            <dc:creator><![CDATA[Steve]]></dc:creator>
            <pubDate>Mon, 11 Dec 2023 16:36:42 GMT</pubDate>
            <atom:updated>2023-12-11T16:36:42.767Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SSLt22eI0pCf412v_yYSgQ.png" /></figure><h3>Measuring the Impact</h3><p>Platform Engineering is becoming the new “it” thing in software development, and it’s no wonder why. For starters, if we use an <strong>IDP</strong> (Internal Developer Platform) we can end up having fewer silos, better reusing components, and reaching an improved developer experience, such that they can self-serve and be more productive. However, adopting this new framework is not as easy as renaming our DevOps. It means the organization has to invest effort and money (especially if we are <a href="https://napptive.com/blog/should-you-build-your-own-idp/">opting to build our IDP</a>). So yes, all that is nice to have, and even quite important, but what’s the return on the investment? In this article, we are going to explore how to quantify the ROI of platform engineering.</p><h3>Business drivers</h3><p>First of all, we need to keep in mind what we are seeking in terms of business. For example, we want to know if we can translate developer autonomy into higher revenue or shorter time-to-market. In a <a href="https://2023.platformcon.com/talks/how-to-measure-roi-and-make-your-platform-effect-visible">recent talk at PlaformCon 2023</a>, <a href="https://www.linkedin.com/in/huuck/?originalSubdomain=au">Dr Ralf Huuck</a> succinctly presented the three main areas where a company can benefit from platform engineering:</p><ul><li><strong>Predictability</strong>: with a platform in place, we gain insight into what we deliver, its cost, and its value. This translates easily into predictable business outcomes in terms of cost/revenue.</li><li><strong>Speed</strong>: an internal platform helps improve three different metrics that are related to speed:</li><li><strong>Time to market</strong>: how long it takes to deliver a solution to customers</li><li><strong>Time to react/fix:</strong> how consistent is our delivery</li><li><strong>Velocity</strong>: how fast are product features shipped</li></ul><p>Better results in any (or preferably the three) of them benefit the agility of the company, meaning you can outperform competitors and be more flexible towards market demands.</p><ul><li><strong>Compliance</strong>: everything around compliance and risk — may it be cybersecurity risk, quality issues, reputational risk, or just simply reporting obligations — can be unified and created much simpler in the course of action when using an IDP.</li></ul><p>Now, let’s move on to how can we measure this so that we can translate advantages into quantitative improvements. How to quantify the ROI of platform engineering</p><p>This can be challenging due to the diverse range of factors involved:</p><ol><li><strong>Cost Savings</strong>: such as reduced infrastructure costs, minimized licensing fees, decreased development time, and savings from automation and process improvements.</li><li><strong>Efficiency Improvements</strong>: for example, increased developer productivity, reduced time spent on environment setup and maintenance, faster deployment cycles, and improved resource utilization.</li><li><strong>Time-to-Market</strong>: the time saved in development, testing, deployment, and release cycles can directly translate into increased revenue or market advantage.</li><li><strong>Quality Enhancements</strong>: reduced defects, increased stability, improved performance, and enhanced user experience, which can lead to higher customer satisfaction, retention, and reduced support costs.</li><li><strong>Developer Satisfaction</strong>: how platform engineering is positively impacting developers’ work experience, collaboration, and productivity.</li><li><strong>Opportunity Cost</strong>: the potential risks, inefficiencies, and limitations of not investing in platform engineering. This can include increased development time, higher maintenance efforts, and missed business opportunities.</li><li><strong>Business Impact</strong>: this includes metrics like increased revenue, improved customer acquisition or retention, accelerated innovation, and competitive advantage.</li></ol><p>It’s important to note that some benefits of platform engineering may be challenging to quantify directly. In such cases, qualitative assessments, surveys, case studies, and anecdotal evidence can help demonstrate the value provided by platform engineering initiatives. Ultimately, a comprehensive ROI assessment should consider a combination of quantitative and qualitative measures to capture the full range of benefits and provide a holistic view of the value generated by platform engineering.</p><p>Here you have three well-known frameworks that can help you assess the ROI of platform engineering for your organization: <strong>DORA</strong>, <strong>SPACE</strong>, and <strong>McKinsey’s</strong>.</p><h3>DORA</h3><p>DORA stands for “DevOps Research &amp; Assessment”. It is “the largest and longest running research program of its kind, that seeks to understand the capabilities that drive software delivery and operations performance”, as stated on <a href="https://dora.dev/">DORA’s project homepage</a>. It has become a standardized framework focused on the stability and velocity of development processes. The framework keeps them in context with each other, as a whole, rather than as independent variables, making the data more challenging to misinterpret or abuse. It is worth noting that it deliberately avoids the more controversial aspects of productivity measurements and individual performance metrics.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*38hpoWlSEnHs5Wyu" /></figure><p><em>(Copyright </em><a href="https://devlake.apache.org/docs/DORA/#what-are-dora-metrics"><em>https://devlake.apache.org/docs/DORA/#what-are-dora-metrics</em></a><em>)</em></p><p>Within the velocity data cluster are two core metrics:</p><ul><li><strong>Deployment Frequency</strong>: Number of successful deployments to production, how rapidly is your team releasing to users?</li><li><strong>Lead Time for Changes</strong>: How long does it take from commit to the code running in production?</li></ul><p>Stability is composed of two core metrics:</p><ul><li><strong>Median Time to Restore Service</strong>: How long does it take the team to properly recover from a failure once it is identified?</li><li><strong>Change Failure Rate</strong>: How often are your deployments causing a failure in production?</li></ul><p>DORA is quite straightforward in the sense that it takes a handful of key metrics to get a reliable picture of how the team — or organization — is performing. To bring the model to life with your data, you can use <a href="https://devlake.apache.org/">DevLake</a>, an open-source dev-data platform that collects, analyzes, and visualizes data from many developer tools like GitHub or Jenkins.</p><h3>SPACE</h3><p>The SPACE Framework is a way to measure the productivity of software engineering teams by using a holistic approach. <a href="https://queue.acm.org/detail.cfm?id=3454124">It was first presented in the ACM journal Queue in 2021</a>. Its name is an acronym that stands for the main factors taken into account in the evaluation:</p><ul><li><strong>Satisfaction and well-being</strong>: how fulfilled, healthy, and happy developers feel at work, as a way to understand and even predict productivity.</li><li><strong>Performance</strong>: the outcome of the development process, in terms of quality and impact.</li><li><strong>Activity</strong>: the count of actions or outputs completed in the course of performing work.</li><li><strong>Communication and collaboration</strong>: how people and teams communicate and work together.</li><li><strong>Efficiency</strong> <strong>and</strong> <strong>flow</strong>: the ability to complete work or make progress on it with minimal interruptions or delays.</li></ul><p>According to its authors, it is important to select just a few metrics that will represent each factor at an individual-, team- or group-, and system level. They acknowledge that most factors are difficult to measure and that individual metrics are inherently limited for properly describing them. In the article, they offer some examples (like the table below) and recommendations when attempting to implement the framework.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/770/0*KEjrXt7qU_RZO_WH" /></figure><p><em>(Copyright </em><a href="https://queue.acm.org/detail.cfm?id=3454124"><em>https://queue.acm.org/detail.cfm?id=3454124</em></a><em>)</em></p><h3>McKinsey</h3><p><a href="https://www.mckinsey.com/industries/technology-media-and-telecommunications/our-insights/yes-you-can-measure-software-developer-productivity">Authors from McKinsey &amp; Company have developed an approach</a> to measuring software developer productivity that is meant to be easier to deploy using surveys or existing data (such as in backlog management tools). They looked to expand on the two sets of metrics already developed by the software industry– DORA and SPACE– with opportunity-focused metrics. There is an example of the framework in action in the image below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*OnZq8_GOG2LflsIy" /></figure><p><em>(Copyright</em> <a href="https://www.mckinsey.com/industries/technology-media-and-telecommunications/our-insights/yes-you-can-measure-software-developer-productivity"><em>https://www.mckinsey.com/industries/technology-media-and-telecommunications/our-insights/yes-you-can-measure-software-developer-productivity</em></a><em>)</em></p><p>The opportunity-focused productivity metrics provide understanding from several viewpoints that were not covered by the other two frameworks:</p><ul><li><strong>Inner/outer loop time spent</strong>: Inner loop activities are directly related to creating the product: coding, building, and unit testing, while outer loop activities are other tasks developers must do to push their code to production: integration, integration testing, releasing, and deployment.</li><li><strong>Developer Velocity Index (DVI) benchmark</strong>: DVI is a survey that measures an enterprise’s technology, working practices, and organizational enablement and benchmarks them against its peers.</li><li><strong>Contribution analysis of individual developers to a team’s backlog:</strong> this insight enables team leaders to manage expectations, improve performance, identify opportunities for training, or rethink the role distribution within a team.</li><li><strong>Talent capability score</strong>: it is a summary of the individual knowledge, skills, and abilities in a given organization.</li></ul><h3>Conclusion</h3><p>In this article, we have stopped for a second to analyze how companies can benefit from using an internal developer platform in terms of business goals. Then, we reviewed all the different factors that weigh in when assessing the <strong>ROI</strong> of an <strong>IDP</strong>. Thankfully, we can count on several frameworks that are widely used for this task to help us along. However, we need to keep in mind that they provide snapshots of how well or badly we are doing in a given moment. If we want to evaluate the gains, we have to measure through time and watch the trends.</p><p>Lastly, if you are not using a developer platform <em>just yet</em> but would like to get an estimate of how your company could benefit from it, don’t worry: fill out <a href="https://napptive.com/project/roi-calculator/">our ROI calculator</a> to find out how much you can gain using <strong>Napptive</strong>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e533a660a0fd" width="1" height="1" alt=""><hr><p><a href="https://medium.com/napptive/how-to-quantify-the-roi-of-platform-engineering-e533a660a0fd">How to Quantify the ROI of Platform Engineering</a> was originally published in <a href="https://medium.com/napptive">NAPPTIVE</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Host your development infrastructure with Napptive — Part III]]></title>
            <link>https://medium.com/napptive/host-your-ide-d5a8aa3d20e6?source=rss-b06f5ef02d66------2</link>
            <guid isPermaLink="false">https://medium.com/p/d5a8aa3d20e6</guid>
            <category><![CDATA[cloud-native]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[visual-studio-code]]></category>
            <category><![CDATA[infrastructure]]></category>
            <category><![CDATA[developer]]></category>
            <dc:creator><![CDATA[Steve]]></dc:creator>
            <pubDate>Mon, 25 Sep 2023 14:02:48 GMT</pubDate>
            <atom:updated>2023-09-25T14:03:21.972Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ApDe2-zhoNLv4VHu.png" /></figure><h3>Host your IDE</h3><p>In this 3 part series of articles, we aimed to demonstrate how you can easily deploy operational applications with Napptive. In the previous two articles, we’ve discussed how you can deploy your own <a href="https://napptive.com/blog/host-your-development-infrastructure-with-napptive-part-1/">Git service, using GOGS</a> followed by the deployment of an <a href="https://napptive.com/blog/host-your-development-infrastructure-with-napptive-part-2/">agile project management software,</a> where we used Taiga to demonstrate the ease of deployment of operational applications with Napptive. This is aimed at reducing deployment time to a very minimum and increasing the efficiency of the operation team of your organization. As stated before, the deployment and configuration of operational applications are as critical to an organization as consumer-facing applications. With Napptive’s IDP, you can seamlessly deploy any app, with ease.</p><p>In this final article of the series, we are going to go ahead and integrate our Git service with one of the most popular open-source code editors and IDEs: <a href="https://code.visualstudio.com/download"><strong>Visual Studio Code</strong></a>. We will show how with Napptive, you get a secure and production-ready VSCode application with support for integration across multiple applications. As well as this, you can use a shared environment to facilitate reusability and efficient usage of existing infrastructure.</p><h3>Deploying OAM of VS-Code to Napptive</h3><p>The OAM definition of our application will look like this. You can modify the definition to include more customizations if required.</p><p>NOTE: Please change the password and sudo password properties in the Secret (in base64 format).</p><pre>apiVersion: core.oam.dev/v1beta1<br>kind: Application<br>metadata:<br>  name: vscode-nodejs<br>  annotations:<br>    version: playground<br>    description: &quot;VSCode IDE with Playground CLI&quot;<br>spec:<br>  components:<br>    - name: vscode-configurations<br>      type: k8s-objects<br>      properties:<br>        objects:<br>          - apiVersion: v1<br>            kind: Secret<br>            metadata:<br>              name: vscode-secrets<br>            type: Opaque<br>            data:<br>              password: cGFzc3dvcmQ=<br>          - apiVersion: v1<br>            kind: ConfigMap<br>            metadata:<br>              name: vscode-configs<br>            data:<br>              PUID: &quot;1000&quot;<br>              PGID: &quot;1000&quot;<br>    - name: vscode-nodejs<br>      dependsOn:<br>        - vscode-configurations<br>      type: webservice<br>      traits:<br>        - type: playground-injector<br>        - type: napptive-ingress<br>          properties:<br>            name: vscode<br>            port: 8080<br>            path: /<br>        - type: storage<br>          properties:<br>            pvc:<br>              - name: vscode-pvc<br>                mountPath: /config<br>                resources:<br>                  requests:<br>                    storage: 1Gi<br>      properties:<br>        image: napptive/vscode-nodejs:latest<br>        cpu: &quot;500m&quot;<br>        memory: 2G<br>        ports:<br>          - port: 8080<br>            expose: true<br>        env:<br>          - name: PUID<br>            valueFrom:<br>              configMapKeyRef:<br>                name: vscode-configs<br>                key: PUID<br>          - name: PGID<br>            valueFrom:<br>              configMapKeyRef:<br>                name: vscode-configs<br>                key: PGID<br>          - name: PASSWORD<br>            valueFrom:<br>              secretKeyRef:<br>                name: vscode-secrets<br>                key: passwordCode language: YAML (yaml)</pre><p>Step 1 — Login to the Napptive Playground</p><p>Go to <a href="https://playground.napptive.dev/">https://playground.napptive.dev</a> and use any of the authentication methods listed to log in.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bWrm0IcMl4t4wJ4O.png" /></figure><p>Step 2 — Select your environment</p><p>From the dropdown menu at the top left, select the appropriate environment where you want to deploy VSCode. Environments are associated with specific <a href="https://docs.napptive.com/zones.html">geographical zones</a>, so choose the one that is closer to your final users for the best experience. Using your own zone also enhances security and control for your applications. For this example, we will deploy VSCode on the test environment, but any other environment will also work without any issues.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/532/0*YH9kNHvmV3oeoctP.png" /></figure><p>Step 3 — Open the catalog to deploy Vscode</p><p>The Napptive Catalog provides a series of ready-to-deploy applications including databases, data-scientist tools, development tools, and many more. Open the catalog through the top left-hand side icon on the sidebar, or through the Deploy app button on the top right-hand side corner. If you are interested in learning more, check how you can upload <a href="https://docs.napptive.com/catalog/upload_app_to_catalog.html">your own applications</a> to the Catalog.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*TyRhgY31tucB9GD-.png" /></figure><p>The next step will show you the <a href="https://docs.napptive.com/app_management/what_is_an_app.html">application definition</a> that will be deployed allowing you to customize it with your own preferences and requirements.</p><p>Update password with a custom one (base64 encoded) in K8s secret object.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rz9M4nBBF8se5_lw.png" /></figure><p><strong>Note:</strong> Default password: “password”</p><p>Step 4 — Click ‘Deploy’ and wait for the application to start</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_cO_6jOrbQSZaymB.png" /></figure><p>Step 5 — Click on the URL in the endpoints section to open VSCode</p><p>Enter the password that you’ve set in the previous step to access VSCode.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*1g8ZuI577wTXuqjb.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_Jy0E1tlUv_hz_eM.png" /></figure><h3>Deploy a shared Git Repository with GOGS on Napptive</h3><p>Deploy GOGS from the Napptive Playground Catalog. Follow <a href="https://napptive.com/blog/host-your-development-infrastructure-with-napptive-part-1/">this article</a> for a detailed walkthrough. The Napptive catalog enables the reusability of applications on your existing infrastructure and easy deployment within clicks.</p><p>After successful deployment, set up a username and password for the initial user (explanation in the article). Then let’s create a new repository “demo” in GOGS.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*uORNvq3xgl2m5SUp.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*zGcZOoaD4-iZiN62.png" /></figure><h3>Configure GOGS on VSCode:</h3><p>Now you have a fully working Linux machine on Napptive with VSCode on it and you can configure git to integrate with GOGS with ease.</p><p>Step 1: Open the terminal in the VSCode application and configure git</p><pre>$ git config --global user.email &quot;&lt;your_email_address_configured_in_gogs&gt;&quot;<br>$ git config --global user.name &quot;&lt;username_configured_in_gogs&gt;&quot;Code language: PHP (php)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Ncb6IkreZ-5AX9h-.png" /></figure><p>Step 2: Clone remote repository</p><p>From the GOGS repository copy the remote link.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/668/0*cOH5WbjLxWpI-L67.png" /></figure><p>And run:</p><pre>$ git clone https://gogs-ingress-cj8815hg2gg97uokhutg.apps.mumbai1.eks.zone.napptive.dev/nimish/demo-repository.gitCode language: PHP (php)</pre><p><strong>NOTE</strong>: If you are asked to give a password, put the password that you’ve set during creating an account during deploying GOGS.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7OiZAzwOVWc50iIp.png" /></figure><p>Step 3: Open the folder in the VSCode workspace from <strong>File &gt; Open Folder</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/562/0*BzhMOl3fYcVx3-8y.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/673/0*U_wqUfXExajGDuMo.png" /></figure><h3>Demo: Creating a sample NodeJS/ExpressJS application</h3><p>Step 1: Initialize the NodeJS project and install dependencies</p><p>Run:</p><pre>$ npm init -y<br>$ npm install express</pre><p>And add the start script to <strong>package.json</strong></p><pre>{<br>  &quot;name&quot;: &quot;workspace&quot;,<br>  &quot;version&quot;: &quot;1.0.0&quot;,<br>  &quot;description&quot;: &quot;&quot;,<br>  &quot;main&quot;: &quot;index.js&quot;,<br>  &quot;scripts&quot;: {<br>    &quot;start&quot;: &quot;node index.js&quot;<br>  },<br>  &quot;keywords&quot;: [],<br>  &quot;author&quot;: &quot;&quot;,<br>  &quot;license&quot;: &quot;ISC&quot;,<br>  &quot;dependencies&quot;: {<br>    &quot;express&quot;: &quot;^4.18.2&quot;<br>  }<br>}Code language: JSON / JSON with Comments (json)</pre><p>Step 2: Write express server</p><p>This will spin up a very basic express server at port 5000.</p><pre>const express = require(&quot;express&quot;);</pre><pre>const app = express();</pre><pre>app.get(&quot;/&quot;, (req, res) =&gt; {<br>    res.send(&quot;HELLO FROM NAPPTIVE EXPRESS! (VSCODE)&quot;)<br>})</pre><pre>app.listen(5000, () =&gt; {<br>    console.log(&quot;Server started&quot;)<br>})Code language: PHP (php)</pre><p>Step 3: Testing</p><p>To test the server, run:</p><pre>$ npm run start</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Mqlya2Qo2HCJRyeT.png" /></figure><p>To access your server:</p><p><strong>URL</strong>: &lt;napptive-vscode-url&gt;/proxy/&lt;PORT&gt;</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*G9-o178bMCkvLSKt.png" /></figure><p>Step 4 — Push updates to the remote GOGS repository</p><pre>$ git add .<br>$ git commit -m : &#39;feat: sample nodejs app&#39;<br>$ git push origin mainCode language: JavaScript (javascript)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*lVfOUOlsXl2QU9Mp.png" /></figure><h3>Deploying application to Napptive Playground using VSCode and Playground CLI</h3><p>Now we are ready to deploy our sample NodeJS/ExpressJS server to Napptive using built-in playground CLI.</p><p>Step 1 — Write a simple OAM definition for the application</p><p>Here we are using the Nodejs launcher application provided by Napptive to easily spin up our application without even needing to containerize our application.</p><p><strong>NOTE</strong>: Change the value of LAUNCHER TARGET REPO to the GOGS repository URL. Pass username and password if required.</p><pre>apiVersion: core.oam.dev/v1beta1<br>kind: Application<br>metadata:<br>  name: demo-nodejs-application<br>  annotations:<br>    version: 0.10.1<br>    description: &quot;demo-node-js&quot;<br>spec:<br>  components:<br>    - name: deploy-nodejs-comp<br>      type: webservice<br>      properties:<br>        image: napptive/playground-launcher-nodejs:18-v1.0.0<br>        cpu: &quot;150m&quot;<br>        memory: 256Mi<br>        # (Optional) if the application exposes a port<br>        ports:<br>            - port: 5000<br>              expose: true<br>        env:<br>            # GitHub repo url<br>            - name: LAUNCHER_TARGET_REPO<br>              Value: &lt;GOGS_REMOTE_URL&gt;<br>      traits: # Traits section<br>        # (Optional) If your application requires to be publicly available to the Internet<br>        - type: napptive-ingress<br>          properties:<br>            #  Port (should match the exposed port on the component)<br>            port: 5000<br>            path: /Code language: YAML (yaml)</pre><p>Step 2 — Login to playground CLI in the VSCode terminal</p><p>Run the following command and follow the instructions to log in to the Playground CLI.</p><pre>$ playground login --headless</pre><p>After successful login, run the following command to check if Playground CLI is able to access your environment.</p><pre>$ playground env listCode language: PHP (php)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/896/0*R5XsBnuCReC1ToqB.png" /></figure><p>Step 3 — Deploy your sample application using Playground CLI</p><pre>$ playground apps deploy &lt;oam_file&gt;.yamlCode language: HTML, XML (xml)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*U9wnkWsYhOZeJanL.png" /></figure><p>Step 4 — Check the status of the application</p><p>Run:</p><pre>$ playground apps</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/668/0*r-SyvmCZBQP6Btnx.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*4UURXDdo-ABLasOE.png" /></figure><p>Step 5 — Access your application using the endpoints URL</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/0*qJG9j-tG2Swk-xjv.png" /></figure><p><strong>That’s it! </strong>It’s really that simple to develop applications using a self-hosted IDE, Git repository, and project management system. You can further integrate databases into your services and the Napptive catalog offers a wide range of databases to choose from with a seamless integration experience.</p><h3>Conclusion</h3><p>In this article series, we’ve covered the invaluable advantages of deploying essential operational applications within Napptive’s IDP that play a crucial role in any organization. We started by delving into the deployment of a self-hosted robust Git repository system, GOGS, to highlight the importance and benefits of the reusability of infrastructure applications using the Napptive platform. Then we’ve emphasized the importance of Agile software development and demonstrated a complete deployment of the robust Agile Project Management System, Taiga.</p><p>Finally, we’ve integrated everything by deploying VSCode and using it in conjunction with GOGS, to demonstrate the reusability of applications within a shared environment.</p><p>We hope this article series has illustrated the importance of operational application deployment and how Napptive makes it easy to deploy and maintain, not only operational but any kind of production application. We highly encourage you to explore our platform and experience the benefits that Napptive’s IDP provides to your organization.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d5a8aa3d20e6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/napptive/host-your-ide-d5a8aa3d20e6">Host your development infrastructure with Napptive — Part III</a> was originally published in <a href="https://medium.com/napptive">NAPPTIVE</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to improve DevEx in your company]]></title>
            <link>https://medium.com/napptive/how-to-improve-devex-in-your-company-8e0d30b6f5c4?source=rss-b06f5ef02d66------2</link>
            <guid isPermaLink="false">https://medium.com/p/8e0d30b6f5c4</guid>
            <category><![CDATA[devex]]></category>
            <category><![CDATA[developer]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Steve]]></dc:creator>
            <pubDate>Mon, 18 Sep 2023 07:37:26 GMT</pubDate>
            <atom:updated>2023-09-18T07:40:01.582Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OTN5N6PxPs4fAThucaVVCg.png" /></figure><p>When your mission is to create applications to make the world a nicer place, your developers are the MVP of your organization. Developer Experience (DevEx), then, becomes more prominent when managing your resources, but what is it exactly, and how can you leverage it?</p><p>DevEx entails very different factors that, together, can make your dev team’s life easier. These factors range from the purely HR-oriented (work-from-home or hybrid arrangements, a healthy company culture…) to the most technical (number of tools needed to perform a task or quality of the documentation).</p><p>Napptive is a ready-to-use Internal Development Platform (IDP) focused on cloud-native application development. And, while it can’t help you with Casual Fridays and pizza parties, it is the tool you need to improve your Developer Experience.</p><h3>Challenges</h3><p>In traditional development environments, developers have to face several obstacles on their way to a smooth work experience.</p><h3>Environment setup</h3><p>Project onboarding procedures are notably absent in most cases, and when they do exist they rely on time and effort on the project’s developers side to help the new colleague set their environment up properly.</p><h3>Inconsistent deployment</h3><p>Deployment inconsistencies are an endless source of frustration. There is nothing worse than spending several hours debugging a piece of code only to realize that you’ve been using the wrong version of one of your tools.</p><h3>Collaboration issues</h3><p>If the entry barriers to participate in a project are high and tricky to overcome, collaboration among projects will be scarce, taking more time and energy than what the collaboration itself is worth, or it simply won’t happen.</p><h3>Enter Napptive’s Internal Developer Platform</h3><p>Napptive offers you a robust IDP that can help you manage these challenges since it was designed to streamline the design, development, and upkeep of your cloud-native applications. We provide an integrated solution that can be used by any member of your organization including developers and non-technical users to deploy applications in modern infrastructures.</p><h3>Environment setup</h3><p>Napptive facilitates the project onboarding process by turning the provisioning hardware procedure into an intuitive and fast task. Setting up an environment becomes immediate, and you can be ready to work in seconds.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Dmd6lh8uHEcnVS1n.png" /></figure><p><em>Environment creation, one click away</em></p><h3>Deployment consistency</h3><p>The Playground supports the Open Application Model (OAM) by default. You can create a YAML with the deployment definition of your application, ending the deployment inconsistencies you may have had in the past.</p><h3>Collaboration flow</h3><p>With its multi-tenant capability, a single cluster infrastructure can serve multiple users with all the security guarantees. This feature enables secure collaboration among teams, fostering innovation.</p><p>All this is presented with our amazing UI, which provides a new layer of understanding for modern cloud-native applications. We take pride in our UX department and their fabulous work creating intuitive interfaces to deal with complex tasks in the most efficient way possible.</p><h3>Key Benefits</h3><p>With Napptive, a lot of the issues your development team faces on a daily basis will be solved or heavily mitigated. Our Playground enhances the coding experience by solving everything that’s around it and letting it shine on its own.</p><ul><li>Forget about painstakingly setting up new environments or deploying a new version of your application: in our Playground, environment setup and application deployment become immediate tasks. We’ve already seen how easily we can create a customized environment, and deployment is just as intuitive and fast. No more waiting for DevOps to intervene, just click and go.</li><li>Consistency is essential for clear communication. When the team is using the same environments, with the same configuration, and sharing the same tools, there is no room for inconsistencies in the CI/CD pipeline. “It works on my computer” moments have their days numbered.</li><li>Collaboration is easier than ever: the Playground’s security directives ensure that the code is accessible only to the people who are meant to access it, and the application definitions following the Open Application Model provide common ground for coherent deployments. Also, including new people in a project is seamless, fostering synergies between teams.</li><li>Lastly, the Playground can be tailored to different development needs. Your work tools should adapt to you, not the other way around, and that’s why Napptive allows customization of nearly every element in your cluster with no difficulty added (from within the same intuitive interface).</li></ul><h3>Getting Started</h3><p>You don’t have to take our word for it: try it today!</p><p>You can sign up for free and start using the Playground immediately. Our recommendation to get started is to <a href="https://docs.napptive.com/getting_started/deploy_first_app_from_catalog.html">follow the tutorial in the official documentation and deploy your first cloud-native application</a> from our catalog. It sounds daunting, but that will give you an idea of how easy and intuitive Napptive really is. The <a href="https://docs.napptive.com/Getting_started.html">Getting Started</a> section has several tutorials available to start working with Kubernetes in this new way, and if you’re more experienced and want to explore what Napptive is really capable of, the <a href="https://docs.napptive.com/guides.html">Guides</a> section has more advanced tasks for you.</p><p>Log in, and have fun!</p><h3>Conclusion</h3><p>DevEx is the group of factors that make or break the relationship that you have with your development team. In this day and age, when the job market is more aggressive than ever, keeping talent inside the organization is one of the keys to success, and loyalty can only be achieved by keeping your workers happy. While part of this noble task relies exclusively on HR’s shoulders, the technical side is as important (if not more) and trickier to manage. Napptive can be a game changer for development teams, solving many of the issues they face in their day-to-day tasks, and freeing them from management tasks so they can do what they do best: code.</p><p><em>The original link to the article can be found here: </em><a href="https://napptive.com/blog/how-to-improve-devex-in-your-company/"><em>https://napptive.com/blog/how-to-improve-devex-in-your-company/</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8e0d30b6f5c4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/napptive/how-to-improve-devex-in-your-company-8e0d30b6f5c4">How to improve DevEx in your company</a> was originally published in <a href="https://medium.com/napptive">NAPPTIVE</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Host your development infrastructure with Napptive — Part 2]]></title>
            <link>https://medium.com/napptive/host-your-development-infrastructure-with-napptive-part-2-68f33fe264e8?source=rss-b06f5ef02d66------2</link>
            <guid isPermaLink="false">https://medium.com/p/68f33fe264e8</guid>
            <category><![CDATA[cloud]]></category>
            <category><![CDATA[cloud-native]]></category>
            <category><![CDATA[git]]></category>
            <category><![CDATA[deployment]]></category>
            <dc:creator><![CDATA[Steve]]></dc:creator>
            <pubDate>Wed, 06 Sep 2023 22:46:24 GMT</pubDate>
            <atom:updated>2023-09-06T22:46:24.411Z</atom:updated>
            <content:encoded><![CDATA[<h3>Host your development infrastructure with Napptive — Part 2</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*D2I89cRCSwSOEv4G.png" /></figure><p>In the first part, we discussed how the term “application” is often linked to end-user-focused software, leaving operational applications overlooked. This is why we began this series of articles showcasing the process of deploying the open-source Git Repository service <a href="https://gogs.io/docs">GOGS</a> with Napptive. If you haven’t checked the first article of the series, you can find it <a href="https://napptive.com/blog/host-your-development-infrastructure-with-napptive-part-1/">here</a>.</p><p>Git and other Version control systems are an integral part of project development and management, and integrating them with sophisticated project management tools is proven to improve developer productivity and efficiency. That’s why, in this part 2 of our 3-part series, we are going to deploy <a href="https://taiga.io/"><strong>Taiga</strong></a>, an open-source and fully-featured project management system built with event-driven microservices architecture with Rabbitmq as the message broker, and demonstrate how simple it is to deploy complex operational applications for your organization all thanks to Napptive.</p><h3>Migrating Taiga to OAM</h3><p>Taiga uses Docker-compose-based deployment steps and doesn’t have official support for Kubernetes yet. The good news is you can find the complete OAM definition we’ve developed to port Taiga to Kubernetes/OAM <a href="https://github.com/napptive/catalog-apps/tree/main/apps/taiga/0.10.0">here</a>.</p><p>We have already uploaded the application to the Napptive catalog, which is the simplest way to deploy, share, and reuse applications with only a couple of clicks!</p><h3>Let’s deploy Taiga</h3><p>Given that Taiga is resource intensive, your environment will require at least <strong>2 CPU cores and 8GB of RAM</strong> to be available to deploy the application. Luckily, you can try Napptive’s PRO edition which, amongst many other features, gives you <strong>4 CPU cores</strong> and <strong>16Gb RAM</strong> completely <a href="https://napptive.com/project/free-30-day-trial/">free for 30 days</a> without any commitment!</p><p>With that being said, let’s get started with the deployment procedure!</p><h3>Step 1 — Login to Napptive Playground</h3><p>Go to <a href="https://playground.napptive.dev/">https://playground.napptive.dev</a> and use any of the authentication methods listed to log in.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*GeqciBhkWZSN53h2" /></figure><h3>Step 2 — Select your environment</h3><p>From the dropdown menu at the top left, select the appropriate environment where you want to deploy GOGS. Environments are associated with specific <a href="https://docs.napptive.com/zones.html">geographical zones</a>, so choose the one that is closer to your final users for the best experience. For this example, we will deploy GOGS on the home lab environment, but any other environment will also work without any issues.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/532/0*W7IlPTKdmiZLNhM_" /></figure><h3>Step 3 — Open the Catalog to Deploy Taiga</h3><p>The Napptive Catalog provides a series of ready-to-deploy applications including databases, data-scientist tools, development tools, and many more. Open the catalog through the top left-hand side icon on the sidebar, or through the Deploy app button on the top right-hand side corner. To learn more check how you can upload <a href="https://docs.napptive.com/catalog/upload_app_to_catalog.html">your own applications</a> to the Catalog.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*GMYpUZA3mriWqGAw" /></figure><p>The next step will show you the <a href="https://docs.napptive.com/app_management/what_is_an_app.html">application definition</a> that will be deployed allowing you to customize it with your own preferences and requirements.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*2d-xFQyvjsQ89Yte" /></figure><p>In the case of Taiga, there are multiple options that can be customized through the environment variables which are defined as K8s ConfigMap and secrets in this application definition. For further reference, check out the <a href="https://community.taiga.io/t/taiga-30min-setup/170">Taiga environment specifications</a>.</p><p>Finally, click Deploy and wait for the services to get ready. It’ll take around 5 minutes for the setup to complete (even when the application state is running) while backend database migrations and configuration applications load.</p><h3>Testing Taiga functionalities:</h3><p>After a successful deployment of Taiga, we can start using it for our day-to-day agile workflows.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*BU92pYzr9L3Z0cxZ" /></figure><h3>Let’s start by setting up a User</h3><p>Select the Sign-up button on the top right-hand side, fill up the details, and click on the Sign-Up button.</p><p><strong>NOTE:</strong> This option can be disabled by default by changing the ConfigMap <strong>publicRegistrationEnabledBE </strong>and <strong>publicRegistrationEnabledFE </strong>options to “False” and “false” respectively. Note the capitalization of “false” on the backend side.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/601/0*QR3MOhQtfa6QBWxq" /></figure><p>On successful authentication, you’ll be redirected to the main dashboard of Taiga.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*zfHZRSlgaaVRr1F-" /></figure><h3>Creating projects in Taiga</h3><p>Taiga being an agile project management software, it primarily provides options to create Scrum and Kanban projects by default. To create one for yourself, select the manage projects options (or create a new project) option on the dashboard.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*PWnaC8h3zkOGHAcm" /></figure><p>Select the project template that you want to create and start filling in its description. Here, let’s go with the Kanban template.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0_Z1-PMrNIfM_cjV" /></figure><p>Finally, click on Create Project and you’ll be redirected to the Kanban board that you’ve just created.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*xNbFB1tscyvqjDM3" /></figure><p>From here, you can create user stories, track timelines of projects and tasks, and many more.</p><p>As we can see, we have a fully working self-hosted Agile project management software up and running in just a couple of clicks.</p><h3>Conclusion</h3><p>In this article we’ve covered hosting your development infrastructure and Taiga project management software on Napptive and witnessed the ease of deploying such complex applications through the application catalog of Napptive, making deploying and maintaining your organizational applications much easier!</p><p>If you haven’t experienced <a href="https://napptive.com/">Napptive</a> yet, we invite you to sign up on the platform for absolutely free and explore how Napptive can help your organization become fully cloud-native.<br>Link to original article here: <a href="https://napptive.com/blog/host-your-development-infrastructure-with-napptive-part-2/">https://napptive.com/blog/host-your-development-infrastructure-with-napptive-part-2/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=68f33fe264e8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/napptive/host-your-development-infrastructure-with-napptive-part-2-68f33fe264e8">Host your development infrastructure with Napptive — Part 2</a> was originally published in <a href="https://medium.com/napptive">NAPPTIVE</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Business Value of an IDP]]></title>
            <link>https://medium.com/napptive/the-business-value-of-an-idp-1b309fd45fa?source=rss-b06f5ef02d66------2</link>
            <guid isPermaLink="false">https://medium.com/p/1b309fd45fa</guid>
            <category><![CDATA[cloud-native]]></category>
            <category><![CDATA[internaldeveloperplatform]]></category>
            <category><![CDATA[developer]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[developer-tools]]></category>
            <dc:creator><![CDATA[Steve]]></dc:creator>
            <pubDate>Mon, 04 Sep 2023 06:45:51 GMT</pubDate>
            <atom:updated>2023-09-04T06:45:51.033Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*lTEZA-P646YVrauc.png" /></figure><p>Nowadays, customers expect to see their favorite applications to be refreshed frequently. As users, we can see that new features and improved functionality updates are constantly rolling in. How to keep up with the competitors’ pace and remain relevant in today’s fast-evolving world? In this article, we will break down how an Internal Developer Platform (IDP) is your best tool for drastically cutting back time to market.</p><p><em>Today’s market is constantly evolving with updates, avoid becoming stagnant!</em></p><h3>Benefits of an Internal Developer Platform</h3><p>An IDP is an internal product that developers use for their everyday work. It combines and integrates all the infrastructure, systems, and tools that they need to achieve maximum efficiency and productivity. As a secondary effect, it also translates into better collaboration, which adds to the goal of shipping updates faster. This is how an IDP achieves all this (and more!).</p><h3>A. Efficiency and Productivity</h3><p>An IDP provides a standardized, automated, and centralized ecosystem for development that will allow fast-release cycles:</p><ul><li><strong>Developer self-service</strong> — Developers have readily available all the tools they need to avoid halts in their workflow. With a few clicks, they have access to resources, environments, integrations, deployments, rollbacks, etc. instead of having to create tickets and wait for their resolution.</li><li><strong>Promotion of automation culture</strong> — Save time by automating tasks such as application configuration or infrastructure management. For example, setting up a new environment is the most common requirement for fresh development, yet it takes a lot of time to manually create one. By streamlining operations, your organization makes more value of both your Dev and Ops teams’ time.</li><li><strong>Lower cognitive load</strong> — Thanks to automation, IDPs also reduce complexity. Cloud-native applications have made managing and deploying software more complex, and not every developer is also an expert on, say, AWS, Kubernetes, or Terraform. A unified platform aids developers in building, testing, and deploying applications with ease, regardless of the underlying architecture.</li></ul><p>In addition to this, there is something to be said about not only being more efficient but also more productive. <strong>Avoiding critical situations, easier auditing, and fast recovery</strong> are key in this sense. Internal Platforms enforce good practices and limit the chance of errors by the establishment of golden paths and role-based access control (RBAC). The platform becomes the place for centralized debugging information. All deployments are versioned. Rollbacks can be done automatically. A good portion of time devoted to failure-fixing can now be freed for adding value.</p><h4>Some examples</h4><p>To illustrate the advantages above, let’s recall some usual pains in software development in which an Internal Developer Platform can help:</p><ol><li>There is a new developer in the company. If there aren’t golden paths, automated processes, or a centralized source of documentation, this person will need many hours to find out how things are done (and will likely misconfigure something).</li><li>When Development teams are ready to start testing in infrastructure, they have to ask an Operations team to provision it. They may be faced with long waits, maybe weeks, before they can continue working on this application, breaking workflows and trains of thought, and unnecessarily delaying its release.</li><li>Infrastructure and application configuration management are usually manual tasks that, in lack of an IDP, developers have to do, instead of using their time to do what they do best — develop.</li><li>As cloud computing becomes more and more prevalent, and without an IDP to reduce the complexity, organizations face the necessity to hire multi-skilled engineers who will be able to successfully handle all these new technologies — which, of course, is difficult and expensive.</li></ol><h3>B. Improved Collaboration</h3><p>It seems counter-intuitive that a tool that promotes self-service will boost collaboration, but it’s true. There are a few factors that weigh in on this result. First of all, the Dev and Ops teams will have a golden opportunity to collaborate during the IDP adoption and maintenance. Developers must point out bottlenecks that Ops will work on alleviating. The Ops team in charge of the IDP should design ideal deployment pipelines and adjust them as developer necessities evolve over time.</p><p>Ideally, such pipelines include the publication of reusable components to the company’s catalog. Standardization and enforcement of good practices lead to consistency and cohesiveness in processes and the codebase. This lets developers from different teams jump into each other’s projects with minimal difficulty because they work with the same set of tools and follow the same best practices.</p><p>Cross-region collaboration is another area where an IDP shines. It empowers Development teams spread across the globe to work together seamlessly, enabling efficient knowledge sharing and fostering a culture of innovation.</p><h3>Tailored to the unique needs of your business</h3><p>An IDP must integrate as much as possible with the organization’s existing infrastructure and culture. The technology culture of a company comprises the stack it uses, its tools, its codebase, and the set of processes being followed. The platform needs to comply with the existing — or desired — source code management, release management strategies, security, and other major processes.</p><p>Such a platform will meet all the organization’s needs and promote the goals that the stakeholders — the company, the developer teams, the operations teams, and the final clients — have set for it. Suppose that a company already uses Crossplane to enable developers to provision infrastructure using yaml files. A customized IDP can integrate the use of Crossplane so that the organization makes use of existing know-how. Letting developers use a well-known tool, instead of making them learn to use yet another one, will help in effectively reducing the cognitive load and resistance to change.</p><h3>Real-World Examples of IDPs Generating Business Value</h3><p>IDPs offer a scalable solution that can accommodate the needs of organizations, regardless of their size. Let’s see how three leading tech companies have brought in an IDP in their structure to solve problems they were struggling with.</p><h3>Uber</h3><p><a href="https://napptive.com/blog/ubers-devpod-case-study/">Uber’s</a> fragmented codebase created issues that permeated library versions, build tools, and dependency management, impacting collaboration and code sharing significantly. In response, Uber decided to transition developers to a remote development environment called DevPod. By consolidating all codebases into a single repository and centralizing the build platform, it managed to attain better dependency management, consistent universal production library versions, and improved support for a standard set of tools and processes. The cherry on the cake was the boosted visibility, collaboration, and code sharing that this transformation brought about.</p><h3>Adidas</h3><p><a href="https://napptive.com/blog/adidas-developer-portal-case-study/">Adidas</a> noticed that routine operations were slowing down the delivery process, curbing spontaneity, and impeding the fast-paced development work that the company needed to stay competitive. So they decided to completely overhaul their approach. They used a combination of advanced methodologies and tools: containerization, agile development, continuous delivery, and the induction of a cloud-native platform encompassing Kubernetes and Prometheus. By adopting these cutting-edge technologies, Adidas was able to create an efficient, streamlined Internal Developer Platform designed to improve speed, operability, and observability.</p><h3>Spotify</h3><p><a href="https://napptive.com/blog/spotifys-backstage-a-case-study/">Spotify’s</a> Backstage is the best well-known IDP of this set. The company infrastructure had become a labyrinth of multifaceted tech stacks, redundant tasks, and disparate documentation, each making infrastructure management increasingly complex. To simplify and streamline the software development process, they set to create a platform that would offer a consistent interface, a standardized backend, and enough flexibility to allow teams to adapt it to their unique needs. Teams found themselves with more time and resources to devote to developing new features and services, rather than wrangling with a complicated infrastructure.</p><h3>Conclusion</h3><p>As <a href="https://www.forbes.com/sites/forbestechcouncil/people/navdeepsinghgill/">Navdeep Singh Gill (global CEO of Xenon Stack)</a> puts it in <a href="https://www.forbes.com/sites/forbestechcouncil/2021/04/16/why-enterprises-need-an-internal-developer-platform-idp/">a Forbes article</a>, “IDPs help rapidly growing enterprises focus on work that provides optimal business value.” By automating routinary tasks, developers can focus on adding value to the organization, releasing faster, bringing up innovative ideas, and engaging in fruitful collaboration. Shortening time-to-market is key in today’s fast-paced world. A self-service platform prevents dependency blocks and ensures Operations-approved configuration and infrastructure management.</p><p>If you want your company to take the next step towards reaching lightning-speed release cycles, consider using Napptive. It is a robust and versatile out-of-the-box IDP that can be customized to meet your business needs. Make the choice that will empower your operations and elevate your team’s productivity to new heights. <a href="https://napptive.com/project/playground/?campaign_source=blogBuildIDP">Try Napptive completely free here</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1b309fd45fa" width="1" height="1" alt=""><hr><p><a href="https://medium.com/napptive/the-business-value-of-an-idp-1b309fd45fa">The Business Value of an IDP</a> was originally published in <a href="https://medium.com/napptive">NAPPTIVE</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[IDPs for Developers]]></title>
            <link>https://medium.com/napptive/idps-for-developers-3cfc270cd6a5?source=rss-b06f5ef02d66------2</link>
            <guid isPermaLink="false">https://medium.com/p/3cfc270cd6a5</guid>
            <category><![CDATA[cloud-native]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[internaldeveloperplatform]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[developer]]></category>
            <dc:creator><![CDATA[Steve]]></dc:creator>
            <pubDate>Mon, 28 Aug 2023 07:21:27 GMT</pubDate>
            <atom:updated>2023-08-28T07:22:43.498Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*InUUCOqg4cr4lca1.png" /></figure><p>As software development becomes more sophisticated and teams get bigger, there is a rising need for an internal platform that would bring streamlined workflows, automation of repetitive tasks, and centralized collaboration. IDPs free developers so they can concentrate on innovation, problem-solving, and code quality. They provide a unified environment for managing development environments, integrating tools, and facilitating continuous integration and deployment. With their ability to boost productivity, efficiency, and collaboration, IDPs are increasingly recognized as essential tools for contemporary software development, driving their rising importance in today’s tech companies. But do not take our word for it. In the next sections, we will break down exactly how IDPs can help developers.</p><h3>How IDPs Empower Developers</h3><p>There are three fundamental ways in which an Internal Platform can make a developer’s life easier: streamlining processes, improving collaboration, and managing environments.</p><h3>A. Streamlined Processes</h3><p>Internal Developer Platforms integrate with tools and frameworks that automate all kinds of tasks:</p><ul><li><strong>Build and Deployment Automation:</strong> CI/CD pipelines to automatically build and deploy code changes to various environments, such as development, staging, and production.</li><li><strong>Code Formatting and Style Enforcement:</strong> Linters and code analysis tools to analyze the code and provide feedback or automatically apply formatting rules. This ensures that the codebase follows a unified style to improve code readability and maintainability across the team.</li><li><strong>Automated Testing:</strong> Test automation frameworks to write and execute tests automatically, including unit tests, integration tests, and regression tests.</li><li><strong>Error Monitoring and Alerting:</strong> Error monitoring and logging tools to automate the detection and alerting of application errors in real-time. This improves application stability and reduces the time spent on manual error detection and troubleshooting.</li><li><strong>Dependency Management and Updates:</strong> The platform can monitor dependencies and notify developers about available updates or security patches on libraries, frameworks, or packages. This saves time and effort while minimizing the risk of using outdated or vulnerable components.</li><li><strong>Code Generation and Templating:</strong> Developers can define templates for commonly used code patterns or project structures. The platform can generate code based on these templates, reducing the need for developers to write boilerplate code manually.</li></ul><h3>B. Improved Collaboration</h3><p>By providing a centralized environment and integrated communication channels, IDPs enable seamless collaboration, knowledge sharing, and improved teamwork. This is done at four levels:</p><ol><li><strong>Centralized Knowledge Repository:</strong> Internal developer platforms serve as a central repository for documentation, code samples, best practices, and other resources. This eliminates fragmented communication channels and ensures that everyone has access to up-to-date information.</li><li><strong>Code Sharing and Reusability:</strong> Developers can publish their reusable components on the platform’s catalog. This reduces duplication of efforts and encourages discussions and feedback on shared code, leading to better code quality.</li><li><strong>Collaborative Tools:</strong> IDPs often provide a suite of collaborative tools that facilitate teamwork, like version control systems, issue trackers, communication channels, etc. Developers can seamlessly collaborate on projects, track progress, communicate with each other, and even seek peer review and learn from constructive feedback.</li><li><strong>Cross-Team Collaboration:</strong> IDPs provide visibility into other teams’ work, allowing for knowledge exchange, and fostering cooperation. Developers can share insights, seek assistance, and collaborate on shared projects more effectively, breaking down silos and promoting a culture of collaboration.</li></ol><h3>C. Environment Management</h3><p>Environment provisioning is a burdensome task that usually implies creating a ticket and waiting. IDPs enforce environment self-service, so that developers can instantly provision new environments, even triggered by a CI/CD pipeline, with the required infrastructure, dependencies, and configurations using predefined templates or scripts. This eliminates the time-consuming manual setup process and reduces the chances of environment-related issues.</p><p>By using containers, automatically created environments can be isolated and closely mimic the production one. Developers can package their applications, along with all the necessary dependencies, into containers to be deployed across different environments, such as staging, <a href="https://napptive.com/blog/kubernetes-for-qa/">testing</a>, or production, ensuring consistent behavior and reducing compatibility issues. Even in the case that the environment gets altered and is no longer in a healthy state, developers can just reload an IT-approved container image and continue working.</p><p>Additionally, IDPs often include monitoring and debugging tools to check the performance of their applications in different environments. They provide insights into resource usage, logs, and metrics, allowing developers to identify and debug issues efficiently.</p><h3>Getting Started with an IDP</h3><p>If you are in the search for an IDP for your team, you should pay attention to the following features:</p><ul><li><strong>Ease of use:</strong> Does it have a user-friendly interface and intuitive workflows? Does the platform provide a seamless experience?</li><li><strong>Centralized collaboration:</strong> Does it offer a centralized collaboration environment? Look for the existence of any integrated communication channel, such as chat, forums, or notifications.</li><li><strong>Integrated development tools:</strong> Does it integrate with a wide range of development tools? Can you integrate the CI/CD pipelines, version control system, issue tracker… that you currently use?</li><li><strong>Scalability and customizability:</strong> Is the platform able to scale with the needs of growing development teams and organizations? Does it provide flexibility and customizability?</li><li><strong>Security and compliance:</strong> Does the IDP incorporate robust security measures? Does it adhere to industry security standards and regulations?</li><li><strong>Support and documentation:</strong> What kind of resources does the platform offer to assist developers? Can you ask for support?</li></ul><p>With these questions in mind, we are proud to present <strong>Napptive</strong> as the IDP that will help you boost your development. It is a Kubernetes developer platform that will let your team accelerate the deployment of cloud-native applications without needing deep infrastructure know-how. Its main features are:</p><h3>Accelerated project deployment</h3><p>Transitioning from local development to a production environment or sharing your work can be complex. With Napptive, you can deploy your projects autonomously and effortlessly without sacrificing control or limiting extensibility.</p><h3>Reduced complexity</h3><p>Deploy your code directly in the cloud without worrying about the provider or the automation process. Napptive is built on open-source technologies, eliminating vendor lock-in. It integrates with Golang, Python, NodeJS, Docker, Helm, GitHub, AWS, Azure, Google Cloud, GKE, RKE2, bare metal and more.</p><h3>Integrated collaboration</h3><p>Napptive’s growing catalog of commonly used applications lets you implement technologies you’re already comfortable with. It offers the same experience you get for single containers but for complete applications, with the ability to create and share your ready-to-deploy apps without complex configuration processes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*a2Xjc6LVs6Y3xNnG" /></figure><h3>Secure, user-friendly platform</h3><p>Napptive makes deploying complex applications on Kubernetes easier and faster. Using KubeVela, it manages the technical details so you don’t need extensive Kubernetes knowledge. You can interact with clusters conveniently, create different environments easily, and trust that your applications are securely managed.</p><h3>Fully Extensible</h3><p>Leverage advanced tools and extensions to radically accelerate the process of creating applications, covering essential requirements such as app-centric monitoring, unified logging, managed secure endpoints, and many more!</p><h3>Conclusion</h3><p>Internal Developer Platforms aid developers by streamlining workflows, ensuring environment self-service, and facilitating collaboration. This way, they can focus on problem-solving, improving code quality, and coming up with innovative ideas. If you want to boost productivity, efficiency, and collaboration in your team, consider using Napptive. <a href="https://napptive.com/project/playground/?campaign_source=blogBuildIDP">You can try it for free here</a>.</p><p>The original article can be found here: <a href="https://napptive.com/blog/idps-for-developers/">https://napptive.com/blog/idps-for-developers/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3cfc270cd6a5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/napptive/idps-for-developers-3cfc270cd6a5">IDPs for Developers</a> was originally published in <a href="https://medium.com/napptive">NAPPTIVE</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Running Deno in Napptive]]></title>
            <link>https://medium.com/napptive/running-deno-in-napptive-cf143a94f050?source=rss-b06f5ef02d66------2</link>
            <guid isPermaLink="false">https://medium.com/p/cf143a94f050</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[cloud-native]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[deno]]></category>
            <dc:creator><![CDATA[Steve]]></dc:creator>
            <pubDate>Mon, 21 Aug 2023 13:31:26 GMT</pubDate>
            <atom:updated>2023-08-21T13:31:26.323Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uYUcpNdfZ2dRDJ7N82KY4g.png" /></figure><p><a href="https://deno.land/">Deno</a> was created in response to limitations in existing JavaScript runtimes like Node.js. Its creator, Ryan Dahl, realized improvements were needed. Among these, was the fact that Node.js has security concerns, such as granting too much access. Deno approaches this issue with strict controls. Another important issue was Node.js’s dependency management, which relies heavily on NPM and could lead to complex configurations for developers. Deno aims to simplify dependency management through a URL-based module system and support TypeScript natively as well.</p><p>For a developer who wants to focus on creating and innovating ideas without worrying about infrastructure, Napptive offers a streamlined process, with an easy and user-friendly interface simplifying the way that you can deploy Deno cloud-natively. In this blog post, we show how you can easily deploy a Deno application with our Playground.</p><h3>Benefits of Deploying Deno Applications with Napptive</h3><p>Running Deno applications with Napptive offers several significant benefits for developers:</p><ol><li><strong>Simplified Deployment:</strong> Napptive provides a user-friendly interface and deployment automation, making it easy to deploy Deno applications without the need for complex setup or configuration.</li><li><strong>Zone Deployment:</strong> Developers can choose from different geographical zones to improve the latency of their deployed Deno apps.</li><li><strong>Control and Privacy:</strong> By self-hosting Deno applications with Napptive, developers retain full control over their apps’ data and ensure data privacy and security. This level of control is particularly crucial for applications with sensitive data or compliance requirements.</li></ol><p>In summary, running <strong>Deno applications in Napptive provides a seamless and efficient solution for deploying</strong>, and managing <strong>Deno apps</strong>.</p><h3>How to Launch a Deno Application?</h3><p>In this example, we have deployed the official <a href="https://github.com/denoland/examples/tree/main/with-apollo">Deno with the Apollo server</a>. It is a GraphQL server that you can set up in minutes and use with your API. Here, we are deploying this with Napptive.</p><pre>apiVersion: core.oam.dev/v1beta1<br>kind: Application<br>metadata:<br>  name: deno-with-apollo<br>spec:<br>  components:<br>    - name: deno-with-apollo # Name of the component<br>      type: deno-runner      # set to deno-runner<br>      properties:<br>        repoURL: https://github.com/denoland/examples # GitHub repository<br>        denoPath: with-apollo/   #Optional (Specific Path of Deno Repository)<br>        entrypoint: main.ts  # Entry point of application<br>        ports: # (Optional) exposed ports to communicate with other services<br>          - port: 8000<br>        ingresses: # (Optional) ingresses to expose to internet<br>        - targetPort: 8000<br>        allowNet: &quot;true&quot;  # Allow network access to the application<br>        allowRead: &quot;true&quot; # Allow file system read access<br>        allowEnv: &quot;true&quot; # Allow environment access for getting and setting variables</pre><p>The above application is composed of a single component of type deno-runner that will deploy any Deno code in Napptive. Notice that complex applications can mix deno-runner components with other types to support cases where databases need to be added, or a proxy API needs to complement the existing JavaScript/Typescript code. To learn more about complex applications, check the <a href="https://docs.napptive.com/oam_definitions/components/deno_runner.html">napptive docs.</a></p><p>To deploy your Deno application, the component offers a set of properties to determine which Git repository will be used to get the code, and which properties need to be passed to the deno run command. For a full list of supported options, check the <a href="https://docs.napptive.com/oam_definitions/components/deno_runner.html">deno-runner component documentation</a>.</p><h3>Properties</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/781/0*Bppz7CUoZRZsoLSj.png" /></figure><h3>How to Deploy Apollo with Deno in Napptive</h3><h3>Step 1 — Login to Napptive Playground</h3><p>Go to <a href="https://playground.napptive.dev/">https://playground.napptive.dev</a> and use any of the authentication methods listed to log in. If you do not have an account, it will automatically create a free account for you.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*VgyusPjawG2k4dkZ.png" /></figure><h3>Step 2 — Select your environment</h3><p>From the dropdown menu at the top left, select the appropriate environment where you want to deploy your Deno application. Environments are associated with specific <a href="https://docs.napptive.com/zones.html">geographical zones,</a> so choose the one that is closer to your final users for the best experience. For this example, we will deploy this app on the deploy-app environment, but any other environment will also work without any issues.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*X6aAhRa5Wpf4afvY.png" /></figure><h3>Step-3: Deploy</h3><p>Click on the Deploy app button on the top right in order to deploy the Deno Application.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*yrCceTrZ_WPkip0b.png" /></figure><h3>Step-4: YAML Deploy</h3><p>Choose the <strong>YAML Deploy</strong> option under the “Deploy app” to deploy the Deno application and copy the previous code <a href="https://docs.google.com/document/d/1hBw1Ik5hBAgH1I8PIVWu7BK6xKXXG8G3__IkBr5ctSE/edit#heading=h.mgc0ohm5s9s">shown</a> above. and paste it into this area.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*nd4IBLwxh5iQFjEf.png" /></figure><p>Click on the deploy button at the bottom right to deploy this application.</p><h3>Step-5: Results</h3><p>Click on “deno-with-apollo” to check the logs, info, and endpoints of the application. After clicking on the application you can see all the information and then <strong>click on endpoints to see the results in the browser.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/998/0*OGCn8S1PI7Ai8qdp.png" /></figure><p><strong>Hurray!! You are able to see your application in the browser.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rP9tW1cgBDCQGeg-.png" /></figure><h3>Testing the Application</h3><p>After clicking on run, you are able to see that this will return our dataset defined in the “resolvers.ts” file.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-nFj7C11py77gYW9.png" /></figure><p>In the previous step, we are able to see both dinosaurs’ names and descriptions but if we want to see just detail of a single dinosaur:</p><p>We have to create a new workspace by clicking on “+” icon and paste the below code into this area:</p><pre>query {<br>  dinosaur(name:&quot;Aardonyx&quot;) {<br>    name<br>    description<br>  }</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*hrfVuNKe3Wx-H_v9.png" /></figure><p>As you can see, we have a fully working Deno application running and deployed.</p><h3>Conclusion</h3><p>Overall, Napptive offers an easy-to-use platform for developers to host their applications on their own infrastructure. In this article, we have covered how to deploy any Deno application with Napptive. With the use of its pre-defined component deno-runner, we are able to deploy applications easily and Deno components can be also combined in an application with any others allowing you to complement your Deno application with databases, APIs, etc. Likewise, we can deploy any Deno applications but make sure to configure properties according to that application. For further reference, read our <a href="https://docs.napptive.com/oam_definitions/components/deno_runner.html">full Deno runner documentation.</a></p><p><em>In case you have not yet tried </em><a href="https://playground.napptive.dev/campaign_source=blog-Deno"><strong><em>Napptive</em></strong></a><em>, we encourage you to sign up for free and discover how we are helping propel the development of cloud-native apps.</em></p><p>Original article published here: <a href="https://napptive.com/blog/running-deno-in-napptive/">https://napptive.com/blog/running-deno-in-napptive/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cf143a94f050" width="1" height="1" alt=""><hr><p><a href="https://medium.com/napptive/running-deno-in-napptive-cf143a94f050">Running Deno in Napptive</a> was originally published in <a href="https://medium.com/napptive">NAPPTIVE</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Host your development infrastructure with Napptive — Part 1]]></title>
            <link>https://medium.com/napptive/host-your-development-infrastructure-with-napptive-part-1-c0e4fc8aa244?source=rss-b06f5ef02d66------2</link>
            <guid isPermaLink="false">https://medium.com/p/c0e4fc8aa244</guid>
            <category><![CDATA[infrastructure-management]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[aws]]></category>
            <dc:creator><![CDATA[Steve]]></dc:creator>
            <pubDate>Mon, 07 Aug 2023 15:37:02 GMT</pubDate>
            <atom:updated>2023-08-07T15:37:02.320Z</atom:updated>
            <content:encoded><![CDATA[<h3>Host your development infrastructure with Napptive — Part 1</h3><h3>Getting Started with Git Repositories</h3><p>The term “application” has become synonymous with consumer-oriented software designed to enhance end-user experiences. However, what often remains overlooked are the critical operational applications that play a crucial role in any organization. These are often the backbone of business operations, handling tasks ranging from internal communication to data management and beyond.</p><p>We are going to produce a three-part series of articles showcasing how you can host your development infrastructure with Napptive, and we will begin the series by deploying <strong>GOGS</strong>, a self-hosted git repository system.</p><h3>Why should you host your own infrastructure?</h3><p>Data security has always been one of the most important aspects that organizations care about. With major organizations such as GitHub starting to use the billions of lines of code that are there in the repositories to build AI models, often organizations’ repository code is at risk of getting exposed. Hence self-hosted solutions are getting popular nowadays.</p><p>You have complete customization control over the whole infrastructure and application, and you can also set up your own infrastructure as a Homelab.</p><p>Deploying to Napptive Catalog makes your infrastructure reusable, making it much easier to redeploy in different environments in multiple zones!</p><p>Let’s get started with the OAM definition.</p><p>apiVersion: v1<br>kind: ConfigMap<br>metadata:<br> name: gogs-config<br>data:<br> app.ini: |<br> RUN_MODE = prod<br> RUN_USER = git<br> BRAND_NAME = napptive-gogs</p><p>; add more production configuration as required or leave as default</p><p>— <br>apiVersion: core.oam.dev/v1beta1<br>kind: Application<br>metadata:<br> name: gogs-deployment<br>spec:<br> components:<br> — name: gogs-webservice<br> type: webservice<br> properties:<br> image: nimish8/gogs<br> cpu: “50m”<br> env:<br> — name: SOCAT_LINK<br> value: “false”<br> memory: “512M”<br> ports:<br> — port: 3000<br> expose: true<br> traits:<br> — type: napptive-ingress<br> properties:<br> name: gogs-ingress<br> port: 3000<br> path: /<br> — type: storage<br> properties:<br> pvc:<br> — name: data<br> mountPath: /data/<br> resources:<br> requests:<br> storage: 1Gi<br> configMap:<br> — name: gogs-config<br> mountPath: /configDir<br> # emptyDir<br> # — name: data<br> # mountPath: /data</p><p>Let’s break down each major component:</p><p><strong>apiVersion</strong>: <strong>core.oam.dev/v1beta1</strong> — Refers to the OAM API defined by <a href="https://github.com/kubevela/kubevela">Kubevel</a>a. It provides all the necessary CRD’s for the Application type so that those can be used by Kubernetes runtime.</p><p><strong>kind</strong>: <strong>Application</strong> — This is the actual CRD defined by Kubevela to refer to a complete application. This is the main entity that the OAM model uses and this is where you define your application components and configurations.</p><p><strong>components</strong> — Defines the actual services and workers that are composed to make the application work. Each service in a microservice architecture can be thought of as a component.</p><p><strong>webservice</strong> is a component type defined by Kubevela that handles network requests. Find more about different component types <a href="https://docs.napptive.com/oam_definitions/components/webservice.html">here</a>.</p><p><strong>traits</strong> — Modifies the services to have extended capabilities such as ingress endpoint, storage classes, and much more. Find more about traits <a href="https://docs.napptive.com/oam_definitions/trait_types.html">here</a>.</p><p>With a basic idea of each <strong>OAM</strong> component defined in the YAML file, we can now go through the file, explaining its working.</p><p>GOGS config map defines the production configurations for the server. Add your own configurations by following <a href="https://gogs.io/docs/installation/configuration_and_run">this link</a>.</p><p>apiVersion: v1<br>kind: ConfigMap<br>metadata:<br> name: gogs-config<br>data:<br> app.ini: |<br> RUN_MODE = prod<br> RUN_USER = git<br> BRAND_NAME = napptive-gogs</p><p>; add more production configuration as required or leave as default</p><p>Gogs web service is the main service that contains wrapper images that contain actual <strong>gogs/gogs</strong> images along with additional scripts to load production configuration. At this level, we also define the port that the application listens to (3000) and CPU and Memory requirements. Also, we change the environment variable <strong>SOCAT_LINK</strong> to false as mentioned in GOGS documentation for <strong>K8s</strong>. For other container options check <a href="https://hub.docker.com/r/gogs/gogs">out this link</a>.</p><p>– name: gogs-webservice<br> type: webservice<br> properties:<br> image: nimish8/gogs<br> cpu: “50m”<br> env:<br> — name: SOCAT_LINK<br> value: “false”<br> memory: “512M”<br> ports:<br> — port: 3000<br> expose: true</p><p>In the <strong>trait section</strong> of the service, first, we use <strong>napptive-ingress</strong> to expose the application to the internet. It also adds SSL certificates so we get HTTPS connection out of the box. <strong>The important</strong> thing to note is that the port defined here should match the service port that is being exposed above.</p><p>traits:<br> — type: napptive-ingress<br> properties:<br> name: gogs-ingress<br> port: 3000<br> path: /</p><p>Secondly, we define the storage trait to include persistent volume to the service as we have to store the repository data.</p><p>NOTE: use <strong>emptyDir</strong> instead of <strong>pvc</strong> if you are using a <strong>Napptive free account.</strong></p><p>– type: storage<br> properties:<br> pvc:<br> — name: data<br> mountPath: /data/<br> resources:<br> requests:<br> storage: 1Gi<br> # emptyDir:<br> # — name: data<br> # mountPath: /data</p><p>Here we are mounting volume at /data path with 1 GB of storage.</p><h3>Deploying a git repository with GOGS on Napptive</h3><p>The best thing about Napptive is that deploying applications is one of the smoothest experiences that you might get. With added support with multi-zonality, you get an amazing experience with the security and control of your application, reduced latency, and instant spin-up of your entire application stack at once.</p><p>With that being said, let’s get started!</p><h3>Step 1 — Login to Napptive Playground</h3><p>Go to <a href="https://playground.napptive.dev/">https://playground.napptive.dev</a> and use any of the authentication methods listed to log in. If you do not have an account, it will automatically create one for you.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*R2xPcmHq08vVv1vF.png" /></figure><h3>Step 2 — Select your environment</h3><p>From the dropdown menu at the top left, select the appropriate environment where you want to deploy GOGS. Environments are associated with specific <a href="https://docs.napptive.com/zones.html">geographical zones</a>, so choose the one that is closer to your final users for the best experience. For this example, we will deploy GOGS on the homelab environment, but any other environment will also work without any issues.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/725/0*Xy02FaQVxCFpLIEH.png" /></figure><h3>Step 3 — Open the Catalog to deploy GOGS</h3><p>The Napptive Catalog provides a series of ready-to-deploy applications including databases, data scientist tools, development tools, and GOGS among others. Open the catalog through the top left-hand side icon on the sidebar, or through the Deploy app button on the top right-hand side corner. To learn more check how you can <a href="https://docs.napptive.com/catalog/upload_app_to_catalog.html">upload your own applications</a> to the Catalog.</p><p>Next, choose ‘gogs’ on the list, and click deploy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/775/0*RREA8slYhs9CG4aR.png" /></figure><p>The next step will show you the <a href="https://docs.napptive.com/app_management/what_is_an_app.html">application definition</a> that will be deployed allowing you to customize it with your own preferences and requirements.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/764/0*qIBtYHIl85OgnwLw.png" /></figure><p>In the case of GOGS, there are several options that can be customized through the <strong>app.ini</strong> file. This file will be stored in a ConfigMap to facilitate the configuration. For a list of all the possible configuration options, check the GOGS <a href="https://github.com/gogs/gogs/blob/main/conf/app.ini">app.ini specification</a>.</p><p>Finally, click Deploy and wait for the services to get ready.</p><h3>Results</h3><p>Voila! There’s your own self-hosted git repository up and running! Click on the endpoints link to visit your application. You can check application logs by visiting the logs section.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/783/0*abxvWoJnNW6OnDb3.png" /></figure><h3>Testing GOGS functionalities</h3><p>Here are the configurations that I’m using for setting up GOGS:</p><ul><li>Database Type: sqlite3</li><li>Path: (default)</li><li>Application URL: &lt;your_gogs_deployment_url&gt; (Important)</li><li>Default Branch: main</li><li>Admin user</li></ul><p><strong>IMPORTANT</strong>: Do not change Run User from git. It’ll raise a permission error otherwise.</p><p>Feel free to tinker with other configurations by setting up an SMTP server, integrating with other Databases, etc.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/966/0*4VtM6PEyk4EF_yLi.png" /></figure><p>Then, click on Install Gogs.</p><p>You’ll be redirected to GOGS Dasboard.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*skVjVbqtfiwytCm4.png" /></figure><p>Let’s perform a couple of Git operations, shall we?</p><h4>Creating new repository:</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Bf9vCGcn22lCOo8Y.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*w25Qk9Wqx_9x2BMW.png" /></figure><h4>Adding files to the repository:</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/964/0*yNzcikPKAycQkq0Y.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KiYdx4Qt3ueNxvs4.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7R-JjYQBE6yZtTZl.png" /></figure><p>After updating the README.md file, let’s pull the latest updated code!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Mz6QizUA3TfENYPn.png" /></figure><p>As we can see, we have a fully working self-hosted Git repository service up and running and deployed with only a couple of clicks!</p><p>You can add more customizations to the config file according to your requirements. Check out GOG’s official <a href="https://gogs.io/">documentation</a>.</p><h3>Conclusion</h3><p>In this article, we’ve covered hosting your infrastructure securely by defining your application in OAM specification and deploying with Napptive, making deploying and maintaining your applications, both operational and consumer-facing applications, much easier.</p><p>By extending its capabilities beyond consumer-oriented applications, <strong>Napptive</strong> opens up a world of possibilities for entire organizations to streamline the deployment of operational applications.</p><p><em>In case you have not yet tried </em><a href="https://playground.napptive.dev/campaign_source=blog-Gogs"><strong><em>Napptive</em></strong></a><em>, we encourage you to sign up for free and discover how we are helping propel the development of cloud-native apps.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c0e4fc8aa244" width="1" height="1" alt=""><hr><p><a href="https://medium.com/napptive/host-your-development-infrastructure-with-napptive-part-1-c0e4fc8aa244">Host your development infrastructure with Napptive — Part 1</a> was originally published in <a href="https://medium.com/napptive">NAPPTIVE</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AWS on Kubernetes, OAM and KubeVela]]></title>
            <link>https://medium.com/napptive/aws-on-kubernetes-oam-and-kubevela-68b55e59d1d7?source=rss-b06f5ef02d66------2</link>
            <guid isPermaLink="false">https://medium.com/p/68b55e59d1d7</guid>
            <category><![CDATA[amazon-web-services]]></category>
            <category><![CDATA[kubevela]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[open-application-model]]></category>
            <dc:creator><![CDATA[Steve]]></dc:creator>
            <pubDate>Thu, 03 Aug 2023 13:56:18 GMT</pubDate>
            <atom:updated>2023-08-03T13:56:18.404Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>AWS</strong> has written a comprehensive post addressing the challenges faced by platform engineers and application developers in the context of cloud-native applications running on <strong>Kubernetes</strong>, and our <strong>CTO Daniel Higuero</strong> was kindly asked to share his expertise on their article.</p><p>The post highlights, among others:</p><ul><li>How a solution based on <strong>KubeVela</strong> can help platform and developer teams work more efficiently on Kubernetes</li><li>How to reduce bi-directional organizational dependencies by means of adding abstractions tailored for specific contexts.</li><li>A method to abstract away the evolution of internal subsystems in Kubernetes</li></ul><p>To address these challenges, the post introduces the concept and usage of two of the main technologies that Napptive leverages, namely the <a href="https://oam.dev/"><strong>Open Application Model</strong> </a>(OAM), and <a href="https://kubevela.io/">KubeVela</a><strong>.</strong></p><p>We are incredibly honored to have been asked to collaborate with AWS in sharing our expertise on this article and we hope you enjoy the article and find it useful if you are planning or already developing cloud-native applications.<br>Read the <a href="https://aws.amazon.com/blogs/containers/application-first-delivery-on-kubernetes-with-open-application-model/">original blog post here</a>!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=68b55e59d1d7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/napptive/aws-on-kubernetes-oam-and-kubevela-68b55e59d1d7">AWS on Kubernetes, OAM and KubeVela</a> was originally published in <a href="https://medium.com/napptive">NAPPTIVE</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Uber’s DevPod — A Case Study]]></title>
            <link>https://medium.com/napptive/ubers-devpod-a-case-study-ae5441201bc6?source=rss-b06f5ef02d66------2</link>
            <guid isPermaLink="false">https://medium.com/p/ae5441201bc6</guid>
            <dc:creator><![CDATA[Steve]]></dc:creator>
            <pubDate>Mon, 17 Jul 2023 10:20:31 GMT</pubDate>
            <atom:updated>2023-07-17T10:20:31.716Z</atom:updated>
            <content:encoded><![CDATA[<h3>Uber’s DevPod — A Case Study</h3><p>One of the most common issues companies often grapple with is that of having complex codebase fragmentation. <strong>Uber</strong>, in 2017, was no exception. Their fragmented codebase created issues that permeated library versions, build tools, and dependency management, impacting collaboration and code sharing significantly. In response, Uber took a bold step — transitioning developers to a remote development environment anchored on Monorepos run on a Kubernetes cluster.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*A_KdjF9vcLpM5Dc-.png" /></figure><p>Copyright Uber: <a href="https://www.uber.com/en-ES/blog/devpod-improving-developer-productivity-at-uber/">https://www.uber.com/en-ES/blog/devpod-improving-developer-productivity-at-uber/</a></p><h3>DevPod: Uber’s Remote Development Environment</h3><p>The decision to migrate to a Monorepo architecture wasn’t a small one. It was a strategic choice recommended by Uber’s build-strategy team to consolidate Uber’s sprawling codebase, which, at the time, spanned over 10 programming languages, 4,000+ services, 500+ web apps, and nine build tools. These were distributed across thousands of repositories, each with its trunk-based development and unique version per third-party library.</p><p>In an effort to combat these issues, Uber launched its proprietary remote development environment, DevPods, which run on <strong>Kubernetes</strong> clusters. With zero setup required, DevPods run in the cloud instead of on developers’ laptops, leading to significant improvements in build times. As of November 2022, over 60% of Uber engineers have embraced this new development environment.</p><p>By consolidating all codebases into a single Monorepo and centralizing the build platform based on Google’s Bazel, Uber managed to attain better dependency management, consistent universal production library versions, and improved support for a standard set of tools and processes. The cherry on the cake was the boosted visibility, collaboration, and code sharing that this transformation brought about.</p><p>However, it wasn’t all smooth sailing. The transition to the new code edit-build-run development loop introduced its own set of challenges. The process became lengthier with cloning, in some cases, taking up hours.</p><h3>A Tailor-made Solution</h3><p>Uber’s DevPods were designed to provide a superior developer experience, allowing engineers to leverage faster machines in a secure, controlled cloud environment. Each DevPod is a custom-fitted container running on a Kubernetes cluster, designed with the necessary tools and resources for seamless development on Uber’s monorepo.</p><p>These cloud-based DevPods boast enhanced performance, near-zero setup time, and advanced security, running the latest stable versions of each dependency. What’s more, DevPods are persistent, ensuring that engineers won’t lose their setups, files, or code changes while working on different devices or collaborating with others.</p><p>The advantages of using DevPods include zero setup and maintenance, top-notch security, and a commitment to low latency. With DevPods, Uber developers can hit the ground running on any of the main monorepos, as tools are ready-to-use, environments are provisioned on-demand, and repositories are pre-cloned.</p><h3>User Experience: An Intuitive Approach</h3><p>Uber engineers are presented with a “flavor” — a Docker image preset with tools, default settings, and configurations for specific groups. This approach, Uber engineers believe, “made perfect sense.” It allows them to base the DevPod image on the production image base, enabling the re-use of their critical production software configuration.</p><p>Moreover, Uber introduced a web-based interface for a smoother first-time experience with DevPods and improved troubleshooting, with plans to extend Devpod Central for visibility into resource usage and consumption.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1015/0*ts_E8n0H4B8IYXTh.png" /></figure><p>Copyright Uber: <a href="https://www.uber.com/en-ES/blog/devpod-improving-developer-productivity-at-uber/">https://www.uber.com/en-ES/blog/devpod-improving-developer-productivity-at-uber/</a></p><h3>Harnessing the Power of Kubernetes</h3><p>The transition from laptops to cloud computing was just the beginning. Kubernetes served as a foundation, offering a host for containers on powerful hardware, networking for container connectivity, and persistent volumes for storing engineering work between restarts.</p><p>Uber used custom resource definitions (CRDs) to extend Kubernetes by providing a data structure stored inside the control plate, eliminating the need for an internal database for Devpod metadata. This also facilitated the creation of and access to Devpods using kubectl.</p><h3>The road ahead</h3><p>DevPods have demonstrated their effectiveness in reducing local Git command performance, improving build times by up to 2.5 times over laptops for complex builds. This innovation has been welcomed by the Uber developer community, with over 60% of Uber software engineers adopting DevPods as of November 2022.</p><p>As Uber continues to refine its developer ecosystem, the future focus is on making DevPods even more seamless for engineers. Some areas of exploration include reducing the time to set up DevPods, creating ephemeral DevPods, and facilitating seamless file transfers between laptops and DevPods.</p><p>Uber’s DevPod stands as a testament to the power of innovation, bridging the gap between the complexities of development and the need for efficiency and speed. As we move forward, the question is no longer about surviving the challenges but about harnessing them for continuous improvement, much like what Uber has done with its DevPod platform.</p><p>In conclusion, the groundbreaking shift pioneered by Uber through DevPods presents a formidable model for remote development environments, which, although impressive, might not be feasible for every organization to adopt. This strategy requires a significant commitment of resources, time, and technical prowess, elements that may not be readily available or viable for all companies.</p><p>Undertaking such an extensive shift could be a daunting prospect for organizations, particularly those lacking wide in-house expertise and resources that can spend years in making such a tool. This is where Napptive’s Internal Developer Platform (IDP) comes into the fold, offering a comprehensive, ready-to-use solution that meets the needs of companies who look for a fully featured IDP that empowers teams without the need for intensive, time-consuming overhauls. This streamlined, out-of-the-box solution is precisely what businesses require to stay competitive in today’s rapidly evolving technological landscape, bridging the gap between present capabilities and future needs effortlessly. Try <a href="https://playground.napptive.dev/campaign_source=blog-uber">Napptive</a>, for free now!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ae5441201bc6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/napptive/ubers-devpod-a-case-study-ae5441201bc6">Uber’s DevPod — A Case Study</a> was originally published in <a href="https://medium.com/napptive">NAPPTIVE</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>