One place for hosting & domains

      Installing

      Installing Countly Community Edition on Ubuntu 20.04


      The Countly analytics platform offers an alternative to the ubiquitous Google Analytics. In contrast to Google Analytics, Countly puts more emphasis on privacy and an all-in-one feature set. Countly’s data gathering offers compliance with GDPR, HIPAA, and other privacy standards. Meanwhile, it provides not just visitor analytics, but also a wider range of analytics related to marketing.

      This tutorial shows you how to start using Countly for your analytics needs. Countly Community Edition is free to use, and it runs in a self-hosted server environment. Through this guide, you can learn all the steps needed to get your own Countly server up and tracking activity on your applications.

      Before You Begin

      1. Familiarize yourself with our
        Getting Started with Linode guide, and complete the steps for setting your Linode’s hostname and timezone.

      2. This guide uses sudo wherever possible. Complete the sections of our
        How to Secure Your Server guide to create a standard user account, harden SSH access, and remove unnecessary network services.

      3. Update your system.

        Debian / Ubuntu

        sudo apt update && sudo apt upgrade

        AlmaLinux / CentOS Stream / Fedora / Rocky Linux

      Note

      This guide is written for a non-root user. Commands that require elevated privileges are prefixed with sudo. If you’re not familiar with the sudo command, see the
      Users and Groups guide.

      Countly provides several installation options, which you can review in the link provided at the end of this tutorial.

      This guide covers the method using the Countly server GitHub repository, which tends to be straightforward as a result of the included installation script.

      These instructions are intended for and have been tested on Ubuntu systems. However, they may work on Debian and CentOS as well. Just be sure to make the necessary substitutions where relevant.

      After the steps on installing Countly, the tutorial includes instructions for two optional setup features to potentially improve your Countly experience: DNS and SSL.

      Installing Countly from the GitHub Repository

      These steps show you how to download the Git repository for Countly and use the included installation script. It also includes the steps you need to configure NGINX to properly serve your Countly interface.

      1. Clone the Countly server GitHub repository. This example clones the repository to the current user’s home directory. The process creates a new subdirectory there, countly-server:

        git clone https://github.com/Countly/countly-server.git
      2. The included installation script requires root access for the installation, so you should first switch to a superuser shell:

      3. Navigate to the subdirectory where the script is held:

        cd /home/example-user/countly-server/bin
      4. Run the installation script:

      5. Afterward, you can exit the superuser shell:

      6. Replace the default NGINX configuration with Countly’s
        own NGINX configuration file. Typically, you can find the default configuration file at /etc/nginx/sites-available/default. However, if this is a brand-new installation, you may have to create it:

        sudo mkdir /etc/nginx/sites-available
        sudo nano /etc/nginx/sites-available/default

        Additionally, you should extend the server_name property with the domain name and/or remote IP address you intend to use to access your Countly server. For instance, this example adds the domain name example.com and the remote IP address 192.0.2.0:

        File: /etc/nginx/sites-available/default
        1
        2
        3
        4
        5
        6
        
        server {
            listen   80;
            listen   [::]:80 ipv6only=on;
            server_name  localhost example.com 192.0.2.0;
        
            access_log  off;
      7. Open the HTTP port (80) on your server’s firewall. Typically, the firewalls on Ubuntu and Debian systems are managed with UFW. Using it, you can open the HTTP port with:

        sudo ufw allow http
        sudo ufw reload
      8. Access your Countly instance by navigating to one of the enabled addresses (that is, the server_name values from the NGINX configuration) in your web browser.

      (Optional) Assign Countly DNS

      Countly does not require you to use DNS for your server. However, doing so can make your Countly instance easier to access. It gives you access to your instance via a custom domain name, rather than just the remote IP address.

      To set up DNS on a Linode server, refer to our collection of guides on the
      Linode DNS manager. The process there is straightforward and can have your server running through a DNS quickly.

      (Optional) Assigning Countly TLS via Let’s Encrypt

      Another optional step is giving your Countly instance an SSL certificate. Doing so secures and encrypts its traffic using HTTPS.

      The following steps show you how to apply an SSL certificate to Countly using
      Certbot. Certbot allows you to easily request and download free certificates from
      Let’s Encrypt.

      1. Open the HTTPS port on your system’s firewall. Like above, you can do this using UFW with the HTTPS keyword:

        sudo ufw allow https
        sudo ufw reload
      2. Update the
        Snap app store. Snap provides application bundles that work across major Linux distributions and comes by default with all Ubuntu releases since 16.04:

        sudo snap install core && sudo snap refresh core
      3. Remove any existing Certbot installation:

      4. Install Certbot:

        sudo snap install --classic certbot
      5. Download a certificate using standalone verification. When prompted, accept the terms of service, enter an email address for notifications about certificate renewals, and enter your Countly server’s domain name:

        sudo certbot certonly --standalone

        Certbot outputs the location from which the new certificate can be accessed. Typically, it stores the required files in the following directory, replacing example.com with your domain name: /etc/letsencrypt/live/example.com.

      6. Access the NGINX site configuration again, and make the following modifications to the beginning of the file.

        These changes first add a server for port 80 that redirects traffic to the HTTPS URL. Then they alter the existing server definition to listen on port 443, the HTTPS port, and to use the SSL certificate created above.

        Replace example.com in this example with your server’s domain name:

        File: /etc/nginx/sites-available/default
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        
        server {
                listen      80;
                server_name localhost;
                access_log  off;
                rewrite ^ https://$host$request_uri? permanent;
        }
        
        server {
                listen   443 ssl;
                server_name  localhost example.com;
        
                ssl_certificate      /etc/letsencrypt/live/example.com/fullchain.pem;
                ssl_certificate_key  /etc/letsencrypt/live/example.com/privkey.pem;
        
                access_log  off;

      Now, when navigating to your Countly instance in a web browser, you should be redirected to the HTTPS URL.

      You can optionally also add your server’s remote IP address to the NGINX configuration above and use that as well to access Countly. However, you may receive a certificate warning in your browser. This is because the certificate was issued for your server’s domain name, not its IP address.

      How to Navigate the Countly Server Interface

      With your Countly instance up and running, you are ready to start setting it up for use. This next series of sections first covers the initial setup within the Countly interface.

      Further on, you can set up a Countly client SDK within your application and see it begin gathering your analytics.

      Creating an Administrator Account and Logging In

      When you first access Countly, you’re presented with a form to register an administrator user for your instance. Keep track of the login information you create here, as this user has administrative control within the Countly instance.

      Countly registration page

      Accessing the address for your Countly instance after this initial setup directs you to the login page.

      Countly login page

      Adding an Application to the Countly Dashboard

      Submitting the form to create your administrator account automatically directs you to a page to create a new application for your Countly instance. Here, you are entering the name and some descriptive information about the application.

      Creating a new application in Countly

      You can also reach this form later from the Countly dashboard by selecting the Add new app button in the upper right.

      Later, you can use the application key created by this process to associate a Countly client with your Countly server instance. Doing so then directs analytics from that client to Countly’s dashboard for the application.

      Accessing the Countly Dashboard

      From there you are directed to your Countly dashboard, the same page you land on for subsequent logins.

      Countly dashboard

      Here, you can survey the analytics generated by your Countly instance and manage all aspects of your Countly operations. You can navigate between and create application entries, and within each, view analytics for visits, events, and more.

      How to Set Up the Countly Client for Analytics

      To have Countly start collecting analytics, you need to embed one of its client SDKs within your application.

      Countly has numerous client SDKs available to fit your needs, from web and mobile apps, to the desktop, server, and beyond. You can see Countly’s
      full list of client SDKs for more information on how to download and operate each.

      To get you started and to demonstrate, the rest of this section walks you through an example using Countly’s web application SDK. It covers how you can make the client available for your web application and even includes example code to embed it. If you don’t have a web application ready, follow our guide
      Deploy a Static Site using Hugo and Object Storage.

      1. Ensure your web application’s client-side code includes or has access to the Countly web SDK file. This can be done multiple ways:

        • The SDK is automatically hosted alongside your Countly instance. Assuming your server’s domain is example.com, you can find the SDK at: example.com/sdk/web/countly.min.js.

        • Additionally, the file itself can be found among the Countly server files. Starting from the base Countly server directory, the SDK file is located at frontend/express/public/sdk/web/countly.min.js. You can then copy that file to an appropriate directory with your web application’s client-side code.

        • The Countly SDK can also be accessed from Countly’s own CDN, which you can learn about in their
          web SDK documentation.

        For these steps, it is assumed that you made a copy of the countly.min.js file from Countly’s server files. The steps also assume that you have added that file to a lib subdirectory within your client-side code.

      2. Add the following code to the head section of one of your application’s web pages.

        Replace EXAMPLE_COUNTLY_APP_KEY with the App Key found in your Countly instance. Likewise, replace https://example.com with your Countly server’s URL or IP address (preceded by http://, or ‘https:// if you set up SSL).

        File: index.html
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        30
        31
        32
        33
        
        <!-- [...] -->
        <script type='text/javascript'>
        
        // Initialize variables to be used by the Countly client.
        var Countly = Countly || {};
        Countly.q = Countly.q || [];
        
        // Provide the application key from the Countly dashboard.
        Countly.app_key = 'EXAMPLE_COUNTLY_APP_KEY';
        
        // Provide the URL for your Countly server instance.
        Countly.url = 'https://example.com';
        
        // These next two start pushing function calls to queue. Both
        // are recommended configurations.
        
        // Track sessions automatically.
        Countly.q.push(['track_sessions']);
        // Track web page views automatically.
        Countly.q.push(['track_pageview']);
        
        // Load the Countly script asynchronously.
        (function() {
            var cly = document.createElement('script'); cly.type = 'text/javascript';
            cly.async = true;
        
            // Replace the URL here with the location of your Countly client SDK file.
            cly.src = 'lib/countly.min.js';
            cly.onload = function(){Countly.init()};
            var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(cly, s);
        })();
        </script>
        <!-- [...] -->

        Note

        Alternatively, you can have Countly automatically generate this code specifically for your applications. Click Management (the wrench icon) in the left-hand toolstrip, then Applications. Choose your application and scroll all the way down to the blue box titled “Need some help with SDK integration?”. Click the Web button and you should be redirected to an address that starts with code.count.ly/integration-web.html. From here, choose where you want to retrieve the countly.min.js file and what features you want to use. When done, click Generate code for code that’s custom-tailored for your application.

      3. Begin incorporating Countly event calls into your application. Here is an example of one such call, used for a button on the pages:

        File: index.html
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        
        <html>
        <head>
        <!-- [...] -->
        <script type='text/javascript'>
        function exampleButtonClicked(ob){
          Countly.q.push(['add_event',{
            key:"asyncButtonClick",
            segmentation: {
              "id": ob.id
            }
          }]);
        }
        </script>
        <!-- [...] -->
        </head>
        <body>
        <!-- [...] -->
        <input type="button" id="exampleButton" onclick="exampleButtonClicked(this)" value="Click This Button">
        <!-- [...] -->
        </body>
        </html>

      Navigating to your web application should now generate page views in Countly. Activating an event, like clicking the button in the above example, similarly now shows in Countly.

      Countly page visitors

      Countly page events

      Conclusion

      You are now ready to run your application’s analytics with Countly. With your own Countly server set up and the client embedded, you can begin diving deeper into your Countly configuration. Take a look through the
      Countly documentation to learn all the possibilities and see more of what Countly is capable of.

      More Information

      You may wish to consult the following resources for additional information
      on this topic. While these are provided in the hope that they will be
      useful, please note that we cannot vouch for the accuracy or timeliness of
      externally hosted materials.



      Source link

      Installing MySQL: A Definitive Guide


      MySQL is one of the most popular SQL-based relational databases. The Community Edition is available at no charge and is widely used across the industry. This guide walks you through installing and updating MySQL Community on Windows, macOS, and Linux (either through the native repositories or MySQL’s own repositories).

      When installing MySQL, you can either install MySQL Server or MySQL client utilities. Installing the entire MySQL Server software is the most common option. This allows you to run a full database server on your system. It also installs all of the client utilities that you might need when working with any MySQL instances (a locally installed one or one on a remote system). If you want to reduce disk usage or know you only need the client utilities, you can install the MySQL client package. Alternatively, consider installing and using the
      MySQL Shell.

      Currently, there are two primary MySQL releases to consider: MySQL 5.7 and MySQL 8.0. Both are still receiving support and updates (until October 2023 and April 2026 respectively). You should likely install MySQL 8.0 unless your application does not yet support it.

      Note

      For additional instructions on installing MySQL on any supported operating system, see the
      Installing and Upgrading MySQL guide in the official documentation.

      Before You Begin

      • Consider other deployment options, such as fully managed solutions or automated installations.

      • Check to see if MySQL is already installed on your system. To determine if MySQL is already installed, run the following command:

        mysql --version
        

        The above command should inform you which version you are using. If this command is not found, continue with the installation steps below. If the installed version differs from the release you want to use, consider first uninstalling it and then continuing with the instructions below.

      Note

      The steps in this guide are written for a non-root user. Commands that require elevated privileges are prefixed with sudo. If you’re not familiar with the sudo command, see the
      Linux Users and Groups guide.

      Installing MySQL on Windows

      1. Open a web browser and navigate to the
        MySQL Installer Downloads page. By default, the latest version of MySQL is displayed. You can also view the installer files for
        8.0 or
        5.7 directly. Alternatively, you can navigate to the Archives tab and select any MySQL release and version you wish.

      2. Select your operating system version, click the Download link corresponding with the package you’d like to install, and then click the No thanks, just start my download link. The file should now start downloading.

      3. Open the downloaded file and follow the prompts to install MySQL on your system.

      Installing MySQL on macOS

      1. Open a web browser and navigate to the
        MySQL Community Server Downloads page. By default, the latest version of MySQL is displayed. You can also view the installer files for
        8.0 or
        5.7 directly. Alternatively, you can navigate to the Archives tab and select any MySQL release and version you wish.

      2. Select your operating system version, click the Download link corresponding with the package you’d like to install, and then click the No thanks, just start my download link. The file should now start downloading.

      3. Open the downloaded file and follow the prompts to install MySQL on your system.

      Installing MySQL on Linux: Native Repositories

      One of the fastest ways to quickly install MySQL on most common Linux distributions is to use the distribution’s default/native repositories. For greater control over the release and version that’s installed, and to get the latest versions faster, you may want to consider using
      MySQL’s own YUM or APT repositories.

      CentOS Stream 8 (and 9), CentOS/RHEL 8 (and 9)

      sudo dnf upgrade && sudo dnf install mysql-server
      

      CentOS/RHEL 7

      MySQL is not available through CentOS 7’s native repositories (see
      CentOS 7 Packages list). Installing the mysql package actually installs the mariadb package. While MariaDB can be used as a drop-in replacement in some cases, it may be preferable to install MySQL through the
      MySQL YUM repository.

      sudo yum update && sudo yum install mariadb-server
      

      Debian

      MySQL is not available through Debian’s native repositories. Instead, Debian includes MariaDB. While MariaDB can be used as a drop-in replacement in some cases, it may be preferable to install MySQL through the
      MySQL APT repository.

      sudo apt update && sudo apt install mariadb-server
      

      Fedora

      sudo dnf update && sudo dnf install mysql-community-server
      

      Ubuntu

      sudo apt update && sudo apt install mysql-server
      

      Replace mysql-server with one of the available packages below. If no version is specified in the package name, the default version is installed.

      • MySQL Server packages: mysql-server

        Target a specific version with mysql-server-5.7 or mysql-server-8.0. See
        Ubuntu Package Search for more.

      • MySQL Client packages: mysql-client

        Target a specific version with mysql-client-5.7 or mysql-client-8.0. See
        Ubuntu Package Search for more.

      Installing MySQL on Linux: MySQL’s Repositories

      Using MySQL’s own repositories provides the latest MySQL versions faster than most native repositories. It also allows you more control over the version that is installed.

      Ubuntu and Debian (APT Repository)

      1. Download the release package for your distribution. Currently, all compatible distributions are combined into a single release package.

        wget https://dev.mysql.com/get/mysql-apt-config_0.8.22-1_all.deb
        

        If you’d like to download the latest version of this file or to select a different distribution, visit the
        MySQL APT Repository Downloads page. To obtain the URL for the file, click the Downloads button next to the package you wish to download, right click on the No thanks, just start my download link, and select Copy Link Address (or similar).

      2. Install the downloaded release package. If you downloaded a different file than featured in the previous step, adjust the filename as needed.

        sudo dpkg -i ./mysql-apt-config_0.8.22-1_all.deb
        
      3. The repository configuration tool should automatically start. If not, you can run it using the following command:

        sudo dpkg-reconfigure mysql-apt-config
        
      4. Within the configuration tool, you can select from the options below to adjust how the repository is configured in your system:

        • MySQL Server & Cluster: Select mysql to add MySQL Server packages, mysql-cluster to add the
          MySQL NDB Cluster, or None to forgo adding either option.

        • MySQL Tools & Connectors: When enabled, this option adds all of the additional tools and utilities included with the MySQL software.

        • MySQL Preview Packages: Leave this option as disabled in production, though non-production environments can enable this to test unreleased features and products.

      5. Run the update command to obtain updated package version and dependency information:

        sudo apt update
        
      6. Install MySQL Server or just the MySQL client tools:

        Additional information about the packages available within MySQL’s APT repository can be found by exploring the repository for your distribution:
        Ubuntu or
        Debian.

      CentOS/RHEL and Fedora (YUM Repository)

      1. Download the release package for your distribution.

        curl -OL [file-url]
        
        • CentOS/RHEL 8: https://dev.mysql.com/get/mysql80-community-release-el8-4.noarch.rpm
        • CentOS/RHEL 7: https://dev.mysql.com/get/mysql80-community-release-el7-6.noarch.rpm
        • Fedora 35: https://dev.mysql.com/get/mysql80-community-release-fc35-3.noarch.rpm
        • Fedora 34: https://dev.mysql.com/get/mysql80-community-release-fc34-4.noarch.rpm

        If you’d like to download the latest file or to select a different distribution, visit the
        MySQL YUM Repository Downloads page. To obtain the URL for the desired file, click the Downloads button next to the package you wish to download, right click on the No thanks, just start my download link, and select Copy Link Address (or similar).

      2. Install the downloaded release package, replacing [filename] with the file you just downloaded.

        sudo yum install [filename]
        

        Once installed, you can view all available packages and all enabled packages by running the commands below:

        yum repolist all | grep mysql
        yum repolist enabled | grep mysql
        
      3. By default, the MySQL 8.0 release will be installed. To switch this to MySQL 5.7 or any other available release, run the following commands:

        • CentOS Stream 8 (and 9), CentOS/RHEL 8 (and 9)

          sudo dnf config-manager --disable mysql80-community
          sudo dnf config-manager --enable mysql57-community
          
        • CentOS/RHEL 7:

          sudo yum-config-manager --disable mysql80-community
          sudo yum-config-manager --enable mysql57-community
          
      4. Within CentOS/RHEL 8 distributions, disable the default MySQL module.

        sudo dnf module disable mysql
        
      5. Install MySQL Server or just the MySQL client tools:

        Additional information about the packages available within MySQL’s YUM repository can be found by
        exploring the repository.

      More Information

      You may wish to consult the following resources for additional information
      on this topic. While these are provided in the hope that they will be
      useful, please note that we cannot vouch for the accuracy or timeliness of
      externally hosted materials.



      Source link

      Installing the Linode CCM on an Unmanaged Kubernetes Cluster – A Tutorial


      Updated by Linode Contributed by Linode

      What is the Linode CCM?

      The Linode Cloud Controller Manager (CCM) provides a way for Kubernetes clusters to access additional Linode services. Linode’s CCM provides access to Linode’s load balancing service, Linode NodeBalancers.

      NodeBalancers provide your Kubernetes cluster with a reliable way of exposing resources to the public internet. The Linode CCM handles the creation and deletion of the NodeBalancer, and, along with other Master Plane components, correctly identifies the resources, and their networking, that the NodeBalancer will route traffic to. Whenever a Kubernetes Service of the LoadBalancer type is created, your Kubernetes cluster will create a Linode NodeBalancer service with the help of the Linode CCM.

      Note

      This guide will show you how to manually install the Linode CCM on an unmanaged Kubernetes cluster. This guide exists to support special use cases. For example, if you would like to experiment with various elements of a Kubernetes control plane.

      If you would like to use Kubernetes for production scenarios and make use of Linode NodeBalancers to expose your cluster’s resources, it is recommended that you use the Linode Kubernetes Engine to deploy your cluster. An LKE cluster’s control plane has the Linode CCM preinstalled and does not require any of the steps included in this guide.

      Similarly, if you would like to deploy an unmanaged Kubernetes cluster on Linode, the best way to accomplish that is using Terraform and the Linode K8s module. The Linode K8s module will also include the Linode CCM preinstalled on the Kubernetes master’s control plane and does not require any of the steps included in this guide.

      If you have used the Linode Kubernetes Engine (LKE) or the Linode Terraform K8s module to deploy your cluster, you should instead refer to the Getting Started with Load Balancing on a Linode Kubernetes Engine (LKE) Cluster guide for steps on adding and configuring NodeBalancers on your Kubernetes cluster.

      In this Guide

      You will manually install the Linode CCM on your unmanaged Kubernetes cluster. This will include:

      Before You Begin

      1. Deploy a new unmanaged Kubernetes cluster. You can deploy an unmanaged Kubernetes cluster on Linode by following the Getting Started with Kubernetes: Use kubeadm to Deploy a Cluster on Linode

        Note

        It is recommended that you install the Linode CCM on a new Kubernetes cluster, as there are a number of issues that prevent the CCM from running on Nodes that are in the “Ready” state.

      2. Ensure you have kubectl installed on your local computer and you can access your Kubernetes cluster with it.

      3. Install Git on your local computer.

      4. Generate a Linode APIv4 token.

      Running the Linode Cloud Controller Manager

      Update Your Cluster Configuration

      In order to run the Linode Cloud Controller Manager:

      • You must start kubelet with the --cloud-provider=external flag.
      • kube-apiserver and kube-controller-manager must NOT supply the --cloud-provider flag.

      These configurations will change the behavior of your cluster and how it interacts with its Nodes. For more details, visit the upstream Cloud Controller documentation.

      Install the Linode CCM

      The Linode CCM’s GitHub repository provides a helper script that creates a Kubernetes manifest file that you can use to install the CCM on your cluster. These steps should be run on your local computer and were tested on a macOS.

      Note

      You will need your Linode APIv4 token to complete the steps in this section.
      1. Clone the Linode CCM’s GitHub repository.

        git clone [email protected]:linode/linode-cloud-controller-manager.git
        
      2. Move into the CCM repository’s deploy directory.

        cd linode-cloud-controller-manager/deploy/
        
      3. Run the generate-manifest.sh script. Ensure you replace $LINODE_API_TOKEN with your own Linode APIv4 token and us-east with the Linode region where your cluster resides. To view a list of regions, you can use the Linode CLI, or you can view the Regions API endpoint.

        ./generate-manifest.sh $LINODE_API_TOKEN us-east
        

        After running the script, you should have a new manifest file in the repo’s deploy directory, ccm-linode.yaml.

      4. Apply the manifest file to your cluster in order to install the Linode CCM and the required supporting resources.

        kubectl create -f ccm-linode.yaml
        

        Note

        You can create your own ccm-linode.yaml manifest file by editing the contents of the ccm-linode-template.yaml file and changing the values of the data.apiToken and data.region fields with your own desired values. This template file is located in the deploy directory of the Linode CCM repository.

      Updating the Linode CCM

      The easiest way to update the Linode CCM is to edit the DaemonSet that creates the Linode CCM Pod. To do so:

      1. Run the edit command to make changes to the CCM Daemonset.

        kubectl edit ds -n kube-system ccm-linode
        
      2. The CCM Daemonset manifest will appear in vim. Press i to enter insert mode. Navigate to spec.template.spec.image and change the field’s value to the desired version tag. For instance, if you had the following image:

        image: linode/linode-cloud-controller-manager:v0.2.2
        

        You could update the image to v0.2.3 by changing the image tag:

        image: linode/linode-cloud-controller-manager:v0.2.3
        

        For a complete list of CCM version tags, visit the CCM DockerHub page.

        Caution

        The CCM Daemonset manifest may list latest as the image version tag. This may or may not be pointed at the latest version. To ensure the latest version, it is recommended to first check the CCM DockerHub page, then use the most recent release.
      3. Press escape to exit insert mode, then type :wq and press enter to save your changes. A new Pod will be created with the new image, and the old Pod will be deleted.

      Next Steps

      Now that you have the Linode CCM installed on your Kubernetes cluster, you can learn how to add and configure Linode NodeBalancers on your cluster.

      This guide is published under a CC BY-ND 4.0 license.



      Source link