One place for hosting & domains

      How To Install Web Apps Using Cloudron on Ubuntu 18.04


      The author selected the Wikimedia Foundation to receive a donation as part of the Write for DOnations program.

      Introduction

      Cloudron is a platform that streamlines the installation and management of apps on your server, like WordPress, Rocket.Chat, Nextcloud, GitLab, OpenVPN, and more. A key benefit of using Cloudron is that it performs end-to-end deployment of apps. It automates tasks such as: provisioning databases, DNS setup, certificate management, centralized user management, and automatic backups.

      Apps on Cloudron also receive automatic updates. The Cloudron team tracks upstream app releases and publishes updates for apps. The user experience of installing and updating apps on your server is very similar to how apps are installed and updated on your smartphone: just click to install and start using them without system administration.

      In this tutorial, you’ll install Cloudron on your server then deploy a WordPress site, as an example, to experience how Cloudron performs complete deployment automation. Finally, to ready your Cloudron instance for production use, you will set up Cloudron to back up to DigitalOcean Spaces.

      Prerequisites

      To follow this tutorial, you’ll need:

      • A server running Ubuntu 18.04 with root access and a sudo, non-root account, you can set this up by following this initial server setup guide.

      • A domain name for app installation. If you use a domain like example.com, Cloudron will install its dashboard at my.example.com and the apps will be installed under subdomains that you specify, like git.example.com, chat.example.com, and so on. It is safe to use a domain that is already in use as long as the my subdomain is available.

      • DNS API keys that Cloudron will use to perform DNS automation. Cloudron supports many DNS providers. If your DNS provider is not supported, you can use the wildcard or manual option. In this tutorial, we will use DigitalOcean DNS. You can generate a DigitalOcean DNS API key following How To Create a Personal Access Token.

      • A DigitalOcean Space with API keys (access and secret). To create a DigitalOcean Space and API keys, see How To Create a DigitalOcean Space and API Key.

      Step 1 — Installing Cloudron

      To begin, you’ll install Cloudron to your server using the official installation script. If you wish to skip this setup step, you can use the Cloudron 1-click image in the DigitalOcean Marketplace. Otherwise, for installing Cloudron manually, continue with this step.

      First, as your non-root user, download the setup script by running the following command:

      • wget https://cloudron.io/cloudron-setup

      Next, to make the setup script executable, run the following the command:

      • chmod +x ./cloudron-setup

      Finally, to install Cloudron, run the following command:

      • sudo ./cloudron-setup --provider digitalocean

      The setup will take around 10 minutes. Once setup is complete, the script will ask your permission to reboot the server, select Y to continue:

      Output

      ############################################## Cloudron Setup (latest) ############################################## Follow setup logs in a second terminal with: $ tail -f /var/log/cloudron-setup.log Join us at https://forum.cloudron.io for any questions. => Installing software-properties-common => Ensure required apt sources => Updating apt and installing script dependencies => Checking version => Downloading version 3.5.0 ... => Installing base dependencies and downloading docker images (this takes some time) ... => Installing version 3.5.0 (this takes some time) ... => Waiting for cloudron to be ready (this takes some time) .... Visit https://<IP> and accept the self-signed certificate to finish setup. The server has to be rebooted to apply all the settings. Reboot now ? [Y/n] Y

      You’ve installed Cloudron on your server, now you can set up your domain and administrator account.

      Step 2 — Setting Up Cloudron

      In this step, you’ll configure Cloudron’s primary domain using the setup wizard and set up your Cloudron account for access. You’ll also provide Cloudron with your DigitalOcean API keys to secure your domain with Let’s Encrypt.

      Once the server has rebooted, navigate to https://your-server-ip in your browser and accept the self-signed certificate.

      In Chrome, you can accept the self-signed certificate by clicking on Advanced and then click Proceed to your-server-ip (unsafe). In Firefox, click on Advanced, then Add Exception, and finally Confirm Security Exception.

      Chrome - Accept Self signed Certificate

      At this point, the Cloudron setup wizard will appear. Provide a domain name and select where you host your domain. Although Cloudron supports many DNS providers, like Cloudflare, Gandi, and GoDaddy, in this tutorial, the examples will follow with the domain using DigitalOcean as the DNS provider.

      Setup DNS

      Provide your DigitalOcean API token and click Next.

      Cloudron will use these keys to configure the DNS and obtain Let’s Encrypt certificates for your domain. Cloudron will redirect to https://my.example.com. The browser address bar will show a green lock to indicate that the connection to your Cloudron installation is now secure. Complete the setup by providing a username and password.

      Setup Administrator

      Once you have setup an Administrator account, you’ll see the No apps installed yet! screen. You’ve finished setting up your Cloudron account. Next you can decide which apps to install.

      Step 3 — Installing Your Apps

      You’re now ready to start installing apps.

      When you click on App Store on the interface, Cloudron will prompt you to create a cloudron.io account. You’ll use this account to manage your subscription and billing. Cloudron is free to use for two apps.

      Create cloudron.io account

      Once you sign up, you can install over 50 apps with a single click. Clicking on an app will bring up the installation dialog. As an example, you can click on the WordPress icon and use the blog subdomain. Once you click Install, Cloudron automatically sets up everything necessary for each app, such as: DNS, databases, certificates, and so on.

      Install WordPress

      When installing an app, you can choose whether the app should integrate with Cloudron’s centralized User management. If you opt to use Cloudron User management, you can log in to the app with your Cloudron username and password. You can then add more users and groups on Cloudron and control if they have access to the app. If you opt to instead leave user management to the app, the app will be pre-setup with an admin account and its credentials will display after installation. You can add more users inside the app itself. Note that apps on Cloudron are always accessible externally—the access control setting only determines how login authentication is done.

      Once installed, you can access the app at https://blog.example.com.

      WordPress

      You’ve installed an app to your Cloudron instance; you can use this process to install any of the available apps. To protect your data, you’ll configure backups in the next step.

      Step 4 — Configuring Backups

      Before using Cloudron in a production environment, it is essential to configure Cloudron to periodically save backups to a location that is external to the server. Unlike server snapshots, Cloudron creates backups individually for each app. The primary advantage of this approach is that apps can be individually rolled back, cloned, and even migrated to another new Cloudron installation.

      Cloudron can back up to any provider that supports S3 API or any external volume. In this tutorial, you will use DigitalOcean Spaces as the backup storage.

      With your DigitalOcean Space set up, you can use the associated API keys following this guide. Then, configure Cloudron backups by going to the Backups view and clicking Configure.

      Configure Backup on DO Spaces

      Cloudron will periodically store backups. If your server crashes or you want to move the server to a different DigitalOcean region, you can create a new Droplet, install Cloudron, and restore your server to the exact state from your backup.

      You’ve connected your Cloudron installation to your DigitalOcean Space and have configured backups. The next reviews some of the other features available with Cloudron.

      Step 5 — Exploring Other Features (Optional)

      Cloudron has centralized user management that allows you to invite team members and set up access control for each user.

      To add a new member, go to the Users view and click on New User. Cloudron will send the new user an email with a sign-up link.

      Users View

      A new user can sign up and start using any applications to which you’ve given them access. For the WordPress example in this tutorial, a new user could immediately access it since you installed the application with the User Management option set to Allow all users on this Cloudron.

      Another common task when managing your Cloudron instance, is installing apps on a domain other than the primary domain. To add a domain, go to the Domains view and click Add Domain. Once completed, you can install apps under this newly added domain.

      Domains View

      Security is always paramount and Cloudron provides turnkey security that includes tracking the details of your Cloudron installation. You can look in the Activity view to see all events logged for your Cloudron as well as all configuration changes.

      Conclusion

      In this tutorial, you installed Cloudron on your server. You then installed the WordPress app without having to manually provision databases, configure DNS, set up certificates, and so on. This WordPress installation will get automatic updates for new releases of WordPress. You configured Cloudron to periodically save backups to DigitalOcean Spaces. Finally, you explored other features that can provide additional protection and features to your Cloudron.

      Manually installing apps on a server is an involved process that has more potential for errors and can be time consuming. Modern web applications use a variety of databases, frameworks, and package managers that can complicate the installation. Furthermore, securing and backing up your applications is a separate process. When manually installing apps to keep them up-to-date, it is necessary to diligently track upstream releases and then apply the updates. Cloudron is a solution that helps you easily deploy and maintain apps on your server.

      To learn some more about Cloudron features, you can consult the documentation pages.

      For questions and discussion, visit the forum.



      Source link

      How to Install Apps on Kubernetes with Helm


      Updated by Linode Written by Linode

      What is Helm?

      Helm is a tool that assists with installing and managing applications on Kubernetes clusters. It is often referred to as “the package manager for Kubernetes,” and it provides functions that are similar to a package manager for an operating system:

      • Helm prescribes a common format and directory structure for packaging your Kubernetes resources, known as a Helm chart.

      • Helm provides a public repository of charts for popular software. You can also retrieve charts from third-party repositories, author and contribute your own charts to someone else’s repository, or run your own chart repository.

      • The Helm client software offers commands for: listing and searching for charts by keyword, installing applications to your cluster from charts, upgrading those applications, removing applications, and other management functions.

      Charts

      The components of a Kubernetes application–deployments, services, ingresses, and other objects–are listed in manifest files (in the YAML file format). Kubernetes does not tell you how you should organize those files, though the Kubernetes documentation does offer a general set of best practices.

      Helm charts are the software packaging format for Helm. A chart specifies a file and directory structure that you follow when packaging your manifests. The structure looks as follows:

      chart-name/
        Chart.yaml
        LICENSE
        README.md
        requirements.yaml
        values.yaml
        charts/
        templates/
        templates/NOTES.txt
      
      File or Directory Description
      Chart.yaml General information about the chart, including the chart name, a version number, and a description.
      LICENSE A plain-text file with licensing information for the chart and for the applications installed by the chart. Optional.
      README.md A Markdown file with instructions that a user of a chart may want to know when installing and using the chart, including a description of the app that the chart installs and the template values that can be set by the user. Optional.
      requirements.yaml A listing of the charts that this chart depends on. This list will specify the chart name version number for each dependency, as well as the repository URL that the chart can be retrieved from. Optional.
      values.yaml Default values for the variables in your manifests’ templates.
      charts/ A directory which stores chart dependencies that you manually copy into your project, instead of linking to them from the requirements.yaml file.
      templates/ Your Kubernetes manifests are stored in the templates/ directory. Helm will interpret your manifests using the Go templating language before applying them to your cluster. You can use the template language to insert variables into your manifests, and users of your chart will be able to enter their own values for those variables.
      templates/NOTES.txt A plain-text file which will print to a user’s terminal when they install the chart. This text can be used to display post-installation instructions or other information that a user may want to know. Optional.

      Releases

      When you tell Helm to install a chart, you can specify variable values to be inserted into the chart’s manifest templates. Helm will then compile those templates into manifests that can be applied to your cluster. When it does this, it creates a new release.

      You can install a chart to the same cluster more than once. Each time you tell Helm to install a chart, it creates another release for that chart. A release can be upgraded when a new version of a chart is available, or even when you just want to supply new variable values to the chart. Helm tracks each upgrade to your release, and it allows you to roll back an upgrade. A release can be easily deleted from your cluster, and you can even roll back release deletions.

      Helm Client and Helm Tiller

      Helm operates with two components:

      • The Helm client software that issues commands to your cluster. You run the client software on your computer, in your CI/CD environment, or anywhere else you’d like

      • A server component runs on your cluster and receives commands from the Helm client software. This component is called Tiller. Tiller is responsible for directly interacting with the Kubernetes API (which the client software does not do). Tiller maintains the state for your Helm releases.

      Before You Begin

      1. Install the Kubernetes CLI (kubectl) on your computer, if it is not already.

      2. You should have a Kubernetes cluster running prior to starting this guide. One quick way to get a cluster up is with Linode’s k8s-alpha CLI command. This guide’s examples only require a cluster with one worker node. We recommend that you create cluster nodes that are at the Linode 4GB tier or higher.

        This guide also assumes that your cluster has role-based access control (RBAC) enabled. This feature became available in Kubernetes 1.6. It is enabled on clusters created via the k8s-alpha Linode CLI.

        Note

        This guide’s example instructions will also result in the creation of a Block Storage Volume and a NodeBalancer, which are also billable resources. If you do not want to keep using the example application after you finish reviewing your guide, make sure to delete these resources afterward.
      3. You should also make sure that your Kubernetes CLI is using the right cluster context. Run the get-contexts subcommand to check:

        kubectl config get-contexts
        
      4. You can set kubectl to use a certain cluster context with the use-context subcommand and the cluster name that was previously output from the get-contexts subcommand:

        kubectl config use-context your-cluster-name
        
      5. It is beneficial to have a registered domain name for this guide’s example app, but it is not required.

      Install Helm

      Install the Helm Client

      Install the Helm client software on your computer:

      • Linux. Run the client installer script that Helm provides:

        curl https://raw.githubusercontent.com/helm/helm/master/scripts/get > get_helm.sh
        chmod 700 get_helm.sh
        ./get_helm.sh
        
      • macOS. Use Homebrew to install:

        brew install kubernetes-helm
        
      • Windows. Use Chocolatey to install:

        choco install kubernetes-helm
        

      Install Tiller on your Cluster

      Tiller’s default installation instructions will attempt to install it without adequate permissions on a cluster with RBAC enabled, and it will fail. Alternative instructions are available which grant Tiller the appropriate permissions:

      Note

      The following instructions provide Tiller to the cluster-admin role, which is a privileged Kubernetes API user for your cluster. This is a potential security concern. Other access levels for Tiller are possible, like restricting Tiller and the charts it installs to a single namespace. The Bitnami Engineering blog has an article which further explores security in Helm.
      1. Create a file on your computer named rbac-config.yaml with the following snippet:

        rbac-config.yaml
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        
        apiVersion: v1
        kind: ServiceAccount
        metadata:
          name: tiller
          namespace: kube-system
        ---
        apiVersion: rbac.authorization.k8s.io/v1
        kind: ClusterRoleBinding
        metadata:
          name: tiller
        roleRef:
          apiGroup: rbac.authorization.k8s.io
          kind: ClusterRole
          name: cluster-admin
        subjects:
          - kind: ServiceAccount
            name: tiller
            namespace: kube-system

        This configuration creates a Kubernetes Service Account for Tiller, and then binds it to the cluster-admin role.

      2. Apply this configuration to your cluster:

        kubectl create -f rbac-config.yaml
        
          
        serviceaccount "tiller" created
        clusterrolebinding "tiller" created
        
        
      3. Initialize Tiller on the cluster:

        helm init --service-account tiller --history-max 200
        

        Note

        The --history-max option prevents Helm’s historical record of the objects it tracks from growing too large.

      4. You should see output like:

        $HELM_HOME has been configured at /Users/your-user/.helm.
        
        Tiller (the Helm server-side component) has been installed into your Kubernetes Cluster.
        
        Please note: by default, Tiller is deployed with an insecure 'allow unauthenticated users' policy.
        To prevent this, run `helm init` with the --tiller-tls-verify flag.
        For more information on securing your installation see: https://docs.helm.sh/using_helm/#securing-your-helm-installation
        Happy Helming!
        
      5. The pod for Tiller will be running in the kube-system namespace:

        kubectl get pods --namespace kube-system | grep tiller
        tiller-deploy-b6647fc9d-vcdms                1/1       Running   0          1m
        

      Use Helm Charts to Install Apps

      This guide will use the Ghost publishing platform as the example application.

      Search for a Chart

      1. Run the repo update subcommand to make sure you have a full list of available charts:

        helm repo update
        

        Note

        Run helm repo list to see which repositories are registered with your client.

      2. Run the search command with a keyword to search for a chart by name:

        helm search ghost
        

        The output will look like:

        NAME            CHART VERSION   APP VERSION DESCRIPTION
        stable/ghost    6.7.7           2.19.4      A simple, powerful publishing platform that allows you to...
        
      3. The full name for the chart is stable/ghost. Inspect the chart for more information:

        helm inspect stable/ghost
        

        This command’s output will resemble the README text available for the Ghost chart in the official Helm chart repository on GitHub.

      Install the Chart

      The helm install command is used to install a chart by name. It can be run without any other options, but some charts expect you to pass in configuration values for the chart:

      1. Create a file named ghost-config.yaml on your computer from this snippet:

        ghost-config.yaml
        1
        2
        
        ghostHost: ghost.example.com
        ghostEmail: email@example.com

        Replace the value for ghostHost with a domain or subdomain that you own and would like to assign to the app, and the value for ghostEmail with your email.

        Note

        If you don’t own a domain name and won’t continue to use the Ghost website after finishing this guide, you can make up a domain for this configuration file.

      2. Run the install command and pass in the configuration file:

        helm install -f ghost-config.yaml stable/ghost
        
      3. The install command returns immediately and does not wait until the app’s cluster objects are ready. You will see output like the following snippet, which shows that the app’s pods are still in the “Pending” state. The text displayed is generated from the contents of the chart’s templates/NOTES.txt file:

        Full output of helm install

        NAME:   oldfashioned-cricket
        LAST DEPLOYED: Tue Apr 16 09:15:41 2019
        NAMESPACE: default
        STATUS: DEPLOYED
        
        RESOURCES:
        ==> v1/ConfigMap
        NAME                      DATA  AGE
        oldfashioned-cricket-mariadb        1     1s
        oldfashioned-cricket-mariadb-tests  1     1s
        
        ==> v1/PersistentVolumeClaim
        NAME              STATUS   VOLUME                CAPACITY  ACCESS MODES  STORAGECLASS  AGE
        oldfashioned-cricket-ghost  Pending  linode-block-storage  1s
        
        ==> v1/Pod(related)
        NAME                               READY  STATUS   RESTARTS  AGE
        oldfashioned-cricket-ghost-64ff89b9d6-9ngjs  0/1    Pending  0         1s
        oldfashioned-cricket-mariadb-0               0/1    Pending  0         1s
        
        ==> v1/Secret
        NAME                TYPE    DATA  AGE
        oldfashioned-cricket-ghost    Opaque  1     1s
        oldfashioned-cricket-mariadb  Opaque  2     1s
        
        ==> v1/Service
        NAME                TYPE          CLUSTER-IP      EXTERNAL-IP  PORT(S)       AGE
        oldfashioned-cricket-ghost    LoadBalancer  10.110.3.191    <pending>    80:32658/TCP  1s
        oldfashioned-cricket-mariadb  ClusterIP     10.107.128.144  <none>       3306/TCP      1s
        
        ==> v1beta1/Deployment
        NAME              READY  UP-TO-DATE  AVAILABLE  AGE
        oldfashioned-cricket-ghost  0/1    1           0          1s
        
        ==> v1beta1/StatefulSet
        NAME                READY  AGE
        oldfashioned-cricket-mariadb  0/1    1s
        
        
        NOTES:
        1. Get the Ghost URL by running:
        
          echo Blog URL  : http://ghost.example.com/
          echo Admin URL : http://ghost.example.com/ghost
        
        2. Get your Ghost login credentials by running:
        
          echo Email:    email@example.com
          echo Password: $(kubectl get secret --namespace default oldfashioned-cricket-ghost -o jsonpath="{.data.ghost-password}" | base64 --decode)
        
      4. Helm has created a new release and assigned it a random name. Run the ls command to get a list of all of your releases:

        helm ls
        

        The output will look as follows:

        NAME        REVISION    UPDATED                     STATUS      CHART       APP VERSION NAMESPACE
        oldfashioned-cricket    1           Tue Apr 16 09:15:41 2019    DEPLOYED    ghost-6.7.7 2.19.4      default
        
      5. You can check on the status of the release by running the status command:

        helm status oldfashioned-cricket
        

        This command will show the same output that was displayed after the helm install command, but the current state of the cluster objects will be updated.

      Access your App

      1. Run the helm status command again and observe the “Service” section:

        ==> v1/Service
        NAME                TYPE          CLUSTER-IP      EXTERNAL-IP     PORT(S)       AGE
        oldfashioned-cricket-ghost    LoadBalancer  10.110.3.191    104.237.148.15  80:32658/TCP  11m
        oldfashioned-cricket-mariadb  ClusterIP     10.107.128.144  <none>          3306/TCP      11m
        
      2. The LoadBalancer that was created for the app will be displayed. Because this example uses a cluster created with Linode’s k8s-alpha CLI (which pre-installs the Linode CCM), the LoadBalancer will be implemented as a Linode NodeBalancer.

      3. Copy the value under the EXTERNAL-IP column for the LoadBalancer and then paste it into your web browser. You should see the Ghost website:

        Ghost home page

      4. Revisit the output from the status command. Instructions for logging into your Ghost website will be displayed:

        1. Get the Ghost URL by running:
        
        echo Blog URL  : http://ghost.example.com/
        echo Admin URL : http://ghost.example.com/ghost
        
        2. Get your Ghost login credentials by running:
        
        echo Email:    email@example.com
        echo Password: $(kubectl get secret --namespace default oldfashioned-cricket-ghost -o jsonpath="{.data.ghost-password}" | base64 --decode)
        
      5. Retrieve the auto-generated password for your app:

        echo Password: $(kubectl get secret --namespace default oldfashioned-cricket-ghost -o jsonpath="{.data.ghost-password}" | base64 --decode)
        
      6. You haven’t set up DNS for your site yet, but you can instead access the admin interface by visiting the ghost URL on your LoadBalancer IP address (e.g. http://104.237.148.15/ghost). Visit this page in your browser and then enter your email and password. You should be granted access to the administrative interface.

      7. Set up DNS for your app. You can do this by creating an A record for your domain which is assigned to the external IP for your app’s LoadBalancer. Review Linode’s DNS Manager guide for instructions.

      Upgrade your App

      The upgrade command can be used to upgrade an existing release to a new version of a chart, or just to supply new chart values:

      1. In your computer’s ghost-config.yaml file, add a line for the title of the website:

        ghost-config.yaml
        1
        2
        3
        
        ghostHost: ghost.example.com
        ghostEmail: email@example.com
        ghostBlogTitle: Example Site Name
      2. Run the upgrade command, specifying the configuration file, release name, and chart name:

        helm upgrade -f ghost-config.yaml oldfashioned-cricket stable/ghost
        

      Roll Back a Release

      Upgrades (and even deletions) can be rolled back if something goes wrong:

      1. Run the helm ls command and observe the number under the “REVISION” column for your release:

        NAME        REVISION    UPDATED                     STATUS      CHART       APP VERSION NAMESPACE
        oldfashioned-cricket    2           Tue Apr 16 10:02:58 2019    DEPLOYED    ghost-6.7.7 2.19.4      default
        
      2. Every time you perform an upgrade, the revision count is incremented by 1 (and the counter starts at 1 when you first install a chart). So, your current revision number is 2. To roll back the upgrade you just performed, enter the previous revision number:

        helm rollback oldfashioned-cricket 1
        

      Delete a Release

      1. Use the delete command with the name of a release to delete it:

        helm delete oldfashioned-cricket
        

        You should also confirm in the Linode Cloud Manager that the Volumes and NodeBalancer created for the app are removed as well.

      2. Helm will still save information about the deleted release. You can list deleted releases:

        helm list --deleted
        

        You can use the revision number of a deleted release to roll back the deletion.

      3. To fully remove a release, use the --purge option with the delete command:

        helm delete oldfashioned-cricket --purge
        

      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.

      Find answers, ask questions, and help others.

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



      Source link

      Deploy Drupal with One-Click Apps


      Updated by Linode

      Contributed by

      Linode

      Drupal One-Click App

      Drupal is a content management system (CMS) designed for building custom websites for personal and business use. Built for high performance and scalability, Drupal provides the necessary tools to create rich, interactive “community” websites with forums, user blogs, and private messaging. Drupal also has support for personal publishing projects and can power podcasts, blogs, and knowledge-based systems, all within a single, unified platform.

      In addition to the core infrastructure, there are a number of freely available Drupal modules that allow administrators of Drupal sites to provide additional functionality, and a robust API makes it easy to enable these features. Furthermore, Drupal has an advanced theming engine that allows for a great amount of flexibility for displaying content.

      Deploy a Drupal One-Click App

      One-Click Apps allow you to easily deploy software on a Linode using the Linode Cloud Manager. To access Linode’s One-Click Apps:

      1. Log in to your Linode Cloud Manager account.

      2. From the Linode dashboard, click on the Create button in the top left-hand side of the screen and select Linode from the dropdown menu.

      3. The Linode creation page will appear. Select the One-Click tab.

      4. Under the Select App section, select the app you would like to deploy:

        Select a One-Click App to deploy

      5. Once you have selected the app, proceed to the app’s Options section and provide values for the required fields.

      The Drupal Options section of this guide provides details on all available configuration options for this app.

      Drupal Options

      You can configure your Drupal App by providing values for the following fields:

      Field Description
      Drupal admin password Password for your Drupal admin profile. Required.
      Drupal admin username Username for your Drupal admin user. Required.
      E-Mail for your Drupal account E-Mail address for your Drupal admin user. Required.
      Your SSH public key Your SSH public key. Advanced Configuration.
      Domain Domain for your Drupal site. Setting a value in this field will not also enable DNS for your app, which you should do as well. Read our DNS Manager guide for instructions on creating DNS records in the Linode Cloud Manager. Advanced Configuration.

      Linode Options

      After providing the app specific options, provide configurations for your Linode server:

      Configuration Description
      Select an Image Debian 9 is currently the only image supported by Drupal One-Click Apps, and it is pre-selected on the Linode creation page. Required.
      Region The region where you would like your Linode to reside. In general, it’s best to choose a location that’s closest to you. For more information on choosing a DC, review the How to Choose a Data Center guide. You can also generate MTR reports for a deeper look at the network routes between you and each of our data centers. Required.
      Linode Plan Your Linode’s hardware resources. Drupal is an extremely flexible CMS that can be supported on any size Linode, but we suggest you deploy your Drupal app on a Linode plan that reflects how much content you plan on featuring as well as how much traffic you expect for your site. For small websites, a 1GB Nanode is sufficient. If you decide that you need more or fewer hardware resources after you deploy your app, you can always resize your Linode to a different plan. Required.
      Linode Label The name for your Linode, which must be unique between all of the Linodes on your account. This name will be how you identify your server in the Cloud Manager’s Dashboard. Required.
      Root Password The primary administrative password for your Linode instance. This password must be provided when you log in to your Linode via SSH. It must be at least 6 characters long and contain characters from two of the following categories: lowercase and uppercase case letters, numbers, and punctuation characters. Your root password can be used to perform any action on your server, so make it long, complex, and unique. Required.

      When you’ve provided all required Linode Options, click on the Create button. Your Drupal app will complete installation anywhere between 2-5 minutes after your Linode has finished provisioning.

      Getting Started after Deployment

      Access your Drupal Site

      After Drupal has finished installing, you will be able to access your Drupal site over http:// with your Linode’s IPv4 address, or the domain name entered when deploying your One-Click App:

      1. Access your Drupal site:

        With your Linode’s IP Address

        You will be able to access your Drupal site by copying your Linode’s IPv4 address and entering it in the browser of your choice. To find your Linode’s IPv4 address:

        1. Click on the Linodes link in the sidebar. You will see a list of all your Linodes.

        2. Find the Linode you just created when deploying your app and select it.

        3. Navigate to the Networking tab.

        4. The IP address will be displayed under the Address column in the IPv4 table.

        5. Copy and paste the IPv4 address into a browser window. You should see the Drupal welcome page appear.

        With a Domain Name

        If you deployed your Drupal One-Click App with a domain name and it is pointing to the Linode’s IP address that is hosting your Drupal instance, then you can enter the domain name in a browser window to access your Drupal site. Ensure you are using http://.

        For more details on registering your domain, see the DNS Manager guide.

      2. Once you have accessed your Drupal site via the browser, you can log in using the admin credentials you created when deploying your app. Then, begin configuring your site.

        Log in to your Drupal site.

      Software Included

      The Drupal One-Click App will install the following required software on your Linode:

      Software Description
      MySQL Server Relational database.
      PHP 7 Drupal is written in PHP and requires PHP to operate.
      Apache HTTP Server Web Server used to serve the Drupal site.
      Drush A command line shell for Drupal.
      Drupal 8 Content management system.

      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.

      Find answers, ask questions, and help others.

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



      Source link