{"id":72096,"date":"2023-03-20T09:01:03","date_gmt":"2023-03-20T09:01:03","guid":{"rendered":"https:\/\/www.cryptocabaret.com\/?p=72096"},"modified":"2023-03-20T09:01:03","modified_gmt":"2023-03-20T09:01:03","slug":"develop-on-kubernetes-with-open-source-tools","status":"publish","type":"post","link":"https:\/\/www.cryptocabaret.com\/?p=72096","title":{"rendered":"Develop on Kubernetes with open source tools"},"content":{"rendered":"

Develop on Kubernetes with open source tools<\/span>
\nrberrelleza<\/a><\/span>
\nMon, 03\/20\/2023 – 03:00<\/span><\/p>\n

\n

Over the last five years, a massive shift in how applications get deployed has occurred. It\u2019s gone from self-hosted infrastructure to the world of the cloud and Kubernetes clusters. This change in deployment practices brought a lot of new things to the world of developers, including containers<\/a>, cloud provider configuration<\/a>, container orchestration<\/a>, and more. There\u2019s been a shift away from coding monoliths towards cloud-native applications consisting of multiple microservices.<\/p>\n

While application deployment has advanced, the workflows and tooling for development have largely remained stagnant. They didn\u2019t adapt completely or feel \u201cnative\u201d to this brave new world of cloud-native applications. This can mean an unpleasant developer experience, involving a massive loss in developer productivity.<\/p>\n

But there\u2019s a better way. What if you could seamlessly integrate Kubernetes and unlimited cloud resources with your favorite local development tools?<\/p>\n

The current state of cloud-native development<\/h2>\n

Imagine that you\u2019re building a cloud-native application that includes a Postgres database in a managed application platform<\/a>, a data set, and three different microservices.<\/p>\n

Normally, this would involve the following steps:<\/p>\n

    \n
  1. Open a ticket to get your IT team to provision a DB in your corporate AWS account.<\/li>\n
  2. Go through documentation to find where to get a copy of last week\u2019s DB dump from your staging environment (you are not using prod data in dev, right?)<\/li>\n
  3. Figure out how to install and run service one on your local machine<\/li>\n
  4. Figure out how to install and run service two on your local machine<\/li>\n
  5. Figure out how to install and run service three on your local machine<\/li>\n<\/ol>\n

    And that\u2019s just to get started. Once you\u2019ve made your code changes, you then have to go through these steps to test them in a realistic environment:<\/p>\n

      \n
    1. Create a Git branch<\/li>\n
    2. Commit your changes<\/li>\n
    3. Figure out a meaningful commit message<\/li>\n
    4. Push your changes<\/li>\n
    5. Wait your turn in the CI queue<\/li>\n
    6. CI builds your artifacts<\/li>\n
    7. CI deploys your application<\/li>\n
    8. You finally validate your changes<\/li>\n<\/ol>\n

      I\u2019ve worked with teams where this process takes anything from a few minutes to several hours. But as a developer, waiting even a few minutes to see whether my code works was a terrible experience. It was slow, frustrating, and made me dread making complex changes.<\/p>\n

      Simplify your cloud-native development workflow with Crossplane and Okteto<\/h2>\n

      Crossplane<\/a> is an open source project that connects your Kubernetes cluster to external, non-Kubernetes resources and allows platform teams to build a custom Kubernetes API to consume those resources. This enables you to do something like kubectl apply -f db.yaml<\/code> to create a database in any cloud provider. And this enables your DevOps or IT team to give you access to cloud infra without having to create accounts, distribute passwords, or manually limit what you can or can\u2019t do. It’s self-service heaven.<\/p>\n

      The Okteto CLI<\/a> is an open source tool that enables you to build, develop, and debug cloud native applications directly in any Kubernetes cluster. Instead of writing code, building, and then deploying in Kubernetes to see your changes, you simply run okteto up<\/code>, and your code changes are synchronized in real time. At the same time, your application is hot-reloaded in the container. It\u2019s a fast inner loop for cloud-native applications.<\/p>\n

      On their own, each of these tools is very useful, and I recommend you try them both. The Crossplane and Okteto projects enable you to build a great developer experience for you and your team, making building cloud-native applications easier, faster, and joyful.<\/p>\n

      Here\u2019s the example I mentioned in the previous section, but instead of a traditional setup, imagine you\u2019re using Crossplane and Okteto:<\/p>\n

        \n
      1. You type okteto up<\/code><\/li>\n
      2. Okteto deploys your services in Kubernetes while Crossplane provisions your database (and data!)<\/li>\n
      3. Okteto synchronizes your code changes and enables hot-reloading in all your services<\/li>\n<\/ol>\n
        \n
        More on Kubernetes<\/div>\n
        \n
        What is Kubernetes?<\/a><\/div>\n
        Free online course: Containers, Kubernetes and Red Hat OpenShift technical over\u2026<\/a><\/div>\n
        Test drive OpenShift hands-on<\/a><\/div>\n
        An introduction to enterprise Kubernetes<\/a><\/div>\n
        How to explain Kubernetes in plain terms<\/a><\/div>\n
        eBook: Running Kubernetes on your Raspberry Pi homelab<\/a><\/div>\n
        Kubernetes cheat sheet<\/a><\/div>\n
        eBook: A guide to Kubernetes for SREs and sysadmins<\/a><\/div>\n
        Latest Kubernetes articles<\/a><\/div>\n<\/p><\/div>\n<\/p><\/div>\n

        At this point, you have a live environment in Kubernetes, just for you. You saved a ton of time by not having to go through IT, figuring out local dependencies, and remembering the commands needed to run each service. And because everything is defined as code, it means that everyone in your team can get their environment in exactly the same way. No degree in cloud infrastructure required.<\/p>\n

        But there\u2019s one more thing. Every time you make a code change, Okteto automatically refreshes your services without requiring you to commit code. There\u2019s no waiting for artifacts to build, no redeploying your application, or going through lengthy CI queues. You can write code, save the file, and see your changes running live in Kubernetes in less than a second.<\/p>\n

        How\u2019s that for a fast cloud-native development experience?<\/p>\n

        Get into the cloud<\/h2>\n

        If you\u2019re building applications meant to run in Kubernetes, why are you not developing in Kubernetes?<\/p>\n

        Using Crossplane and Okteto together gives your team a fast cloud-native development workflow. By introducing Crossplane and Okteto into your team:<\/p>\n