<!DOCTYPE html>
<html lang="en">
<!-- Global site tag (gtag.js) - Google Analytics -->
<script async src="https://www.googletagmanager.com/gtag/js?id=UA-112407000-2"></script>
<script>
    window.dataLayer = window.dataLayer || [];

    function gtag() {
        dataLayer.push(arguments);
    }
    gtag('js', new Date());

    gtag('config', 'UA-112407000-2');
</script>

<!-- Google Tag Manager -->
<script>
    (function (w, d, s, l, i) {
        w[l] = w[l] || [];
        w[l].push({
            'gtm.start': new Date().getTime(),
            event: 'gtm.js'
        });
        var f = d.getElementsByTagName(s)[0],
            j = d.createElement(s),
            dl = l != 'dataLayer' ? '&l=' + l : '';
        j.async = true;
        j.src =
            'https://www.googletagmanager.com/gtm.js?id=' + i + dl;
        f.parentNode.insertBefore(j, f);
    })(window, document, 'script', 'dataLayer', 'GTM-KS8HHSF');
</script>
<!-- End Google Tag Manager -->

<head>
    	<base href="/codewind/" />
	<title>Installing Codewind on the Cloud | Codewind</title>
	<meta charset="utf-8">
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
	<meta name="viewport" content="width=device-width, initial-scale=1">
	<meta name="description" content="Installing Codewind on the Cloud">
	<meta name="keywords" content="build, deploy, IBM Cloud Private, install, installing, installation, chart, Helm, develop, cloud, public cloud, services, command line, cli, command, start, ..."/>
	<link rel="icon" type="image/png" sizes="16x16" href="images/favicon-16x16.png">
	<link rel="icon" type="image/png" sizes="32x32" href="images/favicon-32x32.png">
	<link href="https://fonts.googleapis.com/css?family=IBM+Plex+Sans:300,400,600&display=swap" rel="stylesheet">
	<!-- Bootstrap CSS CDN -->
	<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css"
	integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T" crossorigin="anonymous">
	<link href="https://maxcdn.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css" rel="stylesheet" />
	<link rel="stylesheet" href="css/styles.css">
	<link rel="stylesheet" href="css/docs.css">
	

</head>

<body data-spy="scroll" data-target="#toc">
    <!-- Google Tag Manager (noscript) -->
    <noscript><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-KS8HHSF"
        height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
        <!-- End Google Tag Manager (noscript) -->
    <div class="main">
    <!-- Bootstrap NavBar -->
	<nav class="navbar navbar-expand-lg navbar-light cw-banner fixed-top" aria-label="topnav">
    		        <button class="navbar-toggler navbar-toggler-right" type="button" data-toggle="collapse"
            data-target="#navbarNavDropdown" aria-controls="navbarNavDropdown" aria-expanded="false"
            aria-label="Toggle navigation">
            <span class="navbar-toggler-icon"></span>
        </button>
        <a class="navbar-brand" href="">
            <img alt="Codewind logo image"  title="Codewind logo image" src="images/header-logo.svg" class="cw-header-logo" alt="">
        </a>
        <div class="collapse navbar-collapse justify-content-end cw-navbar-padding" id="navbarNavDropdown">
            <ul class="navbar-nav cw-navbar-nav">
                
                <li class="nav-item cw-navbar-item">
                    <a href="gettingstarted.html" class="btn cw-docs-button">
                    <svg width="16px" height="21px" viewBox="0 0 16 21" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
					    <g id="Page-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
					        <g id="Getting-started" transform="translate(-795.000000, -55.000000)" fill="#0083CA" fill-rule="nonzero">
					            <g id="button" transform="translate(776.000000, 43.000000)">
					                <g id="Group" transform="translate(19.000000, 12.000000)">
					                    <path d="M0.705882353,3.93153323e-06 C0.308729412,0.00284370282 0.00242352941,0.403425659 0,0.715912659 L0,20.2840893 C4.70588235e-05,20.6589153 0.336305882,20.9999503 0.705882353,20.999998 L15.2941172,20.999998 C15.6636936,20.9999503 15.9999525,20.6589153 15.9999995,20.2840893 L15.9999995,5.01136502 C15.9999995,4.82377069 15.9246819,4.6371476 15.7941172,4.50426301 L11.5588231,0.208810644 C11.4277878,0.0763961655 11.2437878,-0.000447090965 11.0588231,3.93153326e-06 L0.705882353,3.93153323e-06 Z M1.41176471,1.43182139 L10.3529407,1.43182139 L10.3529407,5.01136502 C10.3529878,5.38620529 10.6892466,5.72722602 11.0588231,5.72727375 L14.5882348,5.72727375 L14.5882348,19.5681806 L1.41176471,19.5681806 L1.41176471,1.43182139 Z M11.7647054,2.43856803 L13.595576,4.2954563 L11.7647054,4.2954563 L11.7647054,2.43856803 Z M3.29411765,8.11363618 C2.90428235,8.11363618 2.58823529,8.43414851 2.58823529,8.8295449 C2.58823529,9.22491743 2.90428235,9.54545363 3.29411765,9.54545363 L12.7058819,9.54545363 C13.0957407,9.54545363 13.4117642,9.22491743 13.4117642,8.8295449 C13.4117642,8.43414851 13.0957407,8.11363618 12.7058819,8.11363618 L3.29411765,8.11363618 Z M3.29411765,11.9318208 C2.90428235,11.9318208 2.58823529,12.2523332 2.58823529,12.6477296 C2.58823529,13.0431021 2.90428235,13.3636383 3.29411765,13.3636383 L12.7058819,13.3636383 C13.0957407,13.3636383 13.4117642,13.0431021 13.4117642,12.6477296 C13.4117642,12.2523332 13.0957407,11.9318208 12.7058819,11.9318208 L3.29411765,11.9318208 Z M3.29411765,15.7500007 C2.90428235,15.7500007 2.58823529,16.070513 2.58823529,16.4659094 C2.58823529,16.861282 2.90428235,17.1818182 3.29411765,17.1818182 L12.7058819,17.1818182 C13.0957407,17.1818182 13.4117642,16.861282 13.4117642,16.4659094 C13.4117642,16.070513 13.0957407,15.7500007 12.7058819,15.7500007 L3.29411765,15.7500007 Z" id="Shape"></path>
					                </g>
					            </g>
					        </g>
					    </g>
					</svg>
					&nbsp;
                    <span>Docs & Guides</span></a>
                </li>
                
                <li class="nav-item cw-navbar-item cw-header-link">
                    <a class="nav-link cw-nav-link" href="https://twitter.com/EclipseCodewind"><img alt="twitter icon"  title="twitter icon" src="images/banner/twitter.svg"/></a>
                </li>
                <li class="nav-item cw-navbar-item cw-header-link">
                    <a class="nav-link cw-nav-link" href="https://www.youtube.com/channel/UCnKCVK6RFDyHFqUmXlAhCHQ"><img alt="youtube icon"  title="youtube icon" src="images/banner/youtube.svg"/></a>
                </li>
                <li class="nav-item cw-navbar-item cw-header-link">
                    <a class="nav-link cw-nav-link" href="https://mattermost.eclipse.org/eclipse/channels/eclipse-codewind"><img alt="mattermost icon"  title="mattermost icon" src="images/banner/mattermost.svg"/></a>
                </li>
                <li class="nav-item cw-navbar-item cw-header-link">
                    <a class="nav-link cw-nav-link" href="https://github.com/eclipse/codewind"><img alt="github icon"  title="github icon" data-toggle="tooltip" data-placement="top" id="cw_github_stars" title="..." src="images/banner/github.svg"/></a>
                </li>
                <!-- li class="nav-item cw-navbar-item" id="download-li">
                    <button onClick="window.location.href='https://microclimate.dev/download/codewind';" type="button" class="btn cw-download-button">Download</button>
                    <a href="https://microclimate.dev/download/codewind" class="nav-link cw-nav-link cw-download-link" href="#">Download</a>
                </li>  -->


                
                <!-- Smaller devices menu END -->

            </ul>
        </div>

    	</nav>
    	<!-- End Bootstrap NavBar -->
<!-- Bootstrap row -->
<div class="row" id="body-row">
    <!-- Sidebar -->
    <div id="sidebar-container" class="bg-light"  role="navigation" aria-label="sidebar">
        <!-- Bootstrap List Group -->
        <ul class="list-group sticky-top bg-light cw-sticky-offset">
            
            <!-- Hard coded TOC -->
            <!-- Start single page getting started -->
            
			<a href="gettingstarted.html" 
			    
				
				class="bg-light list-group-item list-group-item-action">
				Getting started
            </a>
            
            <!-- End single page getting started -->
            <!-- 
            <a href="#install_on_cloud" data-toggle="collapse" aria-expanded="false" class="bg-light list-group-item list-group-item-action flex-column align-items-start collapsed">
                Getting started
                <span class="submenu-icon"></span>
            </a>
            
            <div id="install_on_cloud" class="cw-sidebar-div cw-sidebar-submenu collapse" style="">
                <a href="mdteclipsegettingstarted.html" 
			        
				    
				    class="bg-light list-group-item list-group-item-action">
				    Installing in Eclipse
                </a>
                <a href="mdt-vsc-getting-started.html" 
			        
				    
				    class="bg-light list-group-item list-group-item-action">
				    Installing in VS Code
                </a>
                <a href="installoncloud.html" 
			        
				    
				    class="cw-current-page bg-light list-group-item list-group-item-action">
				    Installing in Che for Cloud deployments
                </a>
                <a href="importedprojects.html" 
				        
					    
					    class="bg-light list-group-item list-group-item-action">
					    Importing projects
                </a>
            </div>     
             -->
            <a href="#dev_with_codewind" data-toggle="collapse" aria-expanded="false" class="bg-light list-group-item list-group-item-action flex-column align-items-start collapsed">
                <div class="d-flex w-100 justify-content-start align-items-center">
                    <span class="menu-collapsed">Developing with Codewind</span>
                    <span class="submenu-icon"></span>
                </div>
            </a>
            <div id="dev_with_codewind" class="cw-sidebar-div cw-sidebar-submenu collapse" style="">
                <a href="#codewind_for_eclipse" data-toggle="collapse" aria-expanded="false" class="bg-light list-group-item list-group-item-action flex-column align-items-start collapsed">
                    Codewind for Eclipse
                    <span class="submenu-icon"></span>
                </a>
                
                <!-- 3d level - eclipse -->
                <div id="codewind_for_eclipse" class="cw-sidebar-div cw-sidebar-submenu-submenu collapse" style="">
	                <a href="mdteclipseoverview.html" 
				        
					    
					    class="bg-light list-group-item list-group-item-action">
					    Overview
	                </a>
	                
	                
	                <a href="mdt-eclipse-installinfo.html" 
				        
					    
					    class="bg-light list-group-item list-group-item-action">
					    Installing Codewind for Eclipse
	                </a>
	                
	                <a href="mdteclipseusingadifferenttemplate.html" 
				        
					    
					    class="bg-light list-group-item list-group-item-action">
					    Using a template repository of your own
	                </a>
	                <a href="mdteclipseimportedprojects.html" 
				        
					    
					    class="bg-light list-group-item list-group-item-action">
					    Adding existing projects
	                </a>
	                <a href="mdteclipsemanagingprojects.html" 
				        
					    
					    class="bg-light list-group-item list-group-item-action">
					    Managing Codewind projects
	                </a>
	                <a href="mdteclipsebuildproject.html" 
				        
					    
					    class="bg-light list-group-item list-group-item-action">
					    Building Codewind projects
	                </a>
	                <a href="mdteclipsedebugproject.html" 
				        
					    
					    class="bg-light list-group-item list-group-item-action">
					    Debugging Codewind projects
	                </a>
	                <a href="mdteclipsetroubleshooting.html" 
				        
					    
					    class="bg-light list-group-item list-group-item-action">
					    Troubleshooting Codewind for Eclipse
	                </a>
	                <a href="mdteclipseuninstall.html" 
				        
					    
					    class="bg-light list-group-item list-group-item-action">
					    Uninstalling Codewind for Eclipse
	                </a>
                </div>
                <!-- end 3d level eclipse -->
				<!-- vs code -->
				<a href="#codewind_for_vscode" data-toggle="collapse" aria-expanded="false" class="bg-light list-group-item list-group-item-action flex-column align-items-start collapsed">
                    Codewind for VS Code
                    <span class="submenu-icon"></span>
                </a>
                
                <!-- 3d level - vscode -->
                <div id="codewind_for_vscode" class="cw-sidebar-div cw-sidebar-submenu-submenu collapse" style="">
	                <a href="mdt-vsc-overview.html" 
				        
					    
					    class="bg-light list-group-item list-group-item-action">
					    Overview
	                </a>
	                <a href="mdt-vsc-installinfo.html" 
				        
					    
					    class="bg-light list-group-item list-group-item-action">
					    Installing Codewind for VS Code
	                </a>
	                <a href="mdt-vsc-usingadifferenttemplate.html" 
				        
					    
					    class="bg-light list-group-item list-group-item-action">
					    Using a template repository of your own
	                </a>
	                <a href="mdt-vsc-importedprojects.html" 
				        
					    
					    class="bg-light list-group-item list-group-item-action">
					    Adding existing projects
	                </a>
	                <a href="mdt-vsc-tutorial.html" 
				        
					    
					    class="bg-light list-group-item list-group-item-action">
					    Tutorial
	                </a>
	                <a href="mdt-vsc-commands-overview.html" 
				        
					    
					    class="bg-light list-group-item list-group-item-action">
					    Commands overview
	                </a>
	                <a href="mdt-vsc-commands-project.html" 
				        
					    
					    class="bg-light list-group-item list-group-item-action">
					    Project commands
	                </a>
	                <a href="mdt-vsc-commands-restart-and-debug.html" 
				        
					    
					    class="bg-light list-group-item list-group-item-action">
					    Restart and debug commands
	                </a>
	                <a href="mdt-vsc-troubleshooting.html" 
				        
					    
					    class="bg-light list-group-item list-group-item-action">
					    Troubleshooting
	                </a>
	                <a href="mdt-vsc-uninstall.html" 
				        
					    
					    class="bg-light list-group-item list-group-item-action">
					    Uninstalling
	                </a>
	            </div>
	            
				<!--  end vscode  -->
				
				
				<!-- che -->
				<a href="#codewind_for_che" data-toggle="collapse" aria-expanded="false" class="bg-light list-group-item list-group-item-action flex-column align-items-start collapsed">
                    Codewind for Eclipse Che
                    <span class="submenu-icon"></span>
                </a>
                
                <!-- 3d level - che -->
                <div id="codewind_for_che" class="cw-sidebar-div cw-sidebar-submenu-submenu collapse" style="">
	                <a href="installoncloud.html" 
				        
					    
					    class="cw-current-page bg-light list-group-item list-group-item-action">
					    Overview
	                </a>
	                <a href="dockerregistry.html" 
				        
					    
					    class="bg-light list-group-item list-group-item-action">
					    Docker Registry Guidance
	                </a>
	                <a href="openshiftregistry.html" 
				        
					    
					    class="bg-light list-group-item list-group-item-action">
					    Using the OpenShift Registry
	                </a>
	                <a href="supportingmultipleusers.html" 
				        
					    
					    class="bg-light list-group-item list-group-item-action">
					    Support for multiple users
	                </a>
	                <a href="viewkibanalogs.html" 
				        
					    
					    class="bg-light list-group-item list-group-item-action">
					    Installing Kibana and filtering logs in IBM Cloud Private
	                </a>
	            </div>
	            
				<!--  end che  -->
				
				           				
            </div>

            <a href="guide_performance.html" 
			    
				
				class="bg-light list-group-item list-group-item-action">
				Performance monitoring
            </a>

            <a href="codewindandtektonpipelines.html" 
			    
				
				class="bg-light list-group-item list-group-item-action">
				Codewind and Tekton pipelines
            </a>

			<a href="#openapi_tools" data-toggle="collapse" aria-expanded="false" class="bg-light list-group-item list-group-item-action flex-column align-items-start collapsed">
                <div class="d-flex w-100 justify-content-start align-items-center">
                    <span class="menu-collapsed">OpenAPI Tools</span>
                    <span class="submenu-icon"></span>
                </div>
            </a>
            <div id="openapi_tools" class="cw-sidebar-div cw-sidebar-submenu collapse" style="">
                <a href="open-api-tools-for-vscode.html" 
			    
			    
				class="bg-light list-group-item list-group-item-action">
				Codewind OpenAPI Tools for VS Code
				</a>
				<a href="open-api-tools-for-eclipse.html" 
				   
				   
			    class="bg-light list-group-item list-group-item-action">
			    Codewind OpenAPI Tools for Eclipse
				</a>
            </div>
            
            <a href="troubleshooting.html" 
			    
				
				class="bg-light list-group-item list-group-item-action flex-column align-items-start">
				Troubleshooting
            </a>
            
            
            
            
            
            <!-- END hard coded TOC -->

            
        </ul>
        <!-- List Group END-->
    </div>
    <!-- sidebar-container END -->
    <!-- MAIN -->
    <div id="content-container">
    		<div class="py-5 px-5">
    		    <div class="cw-docs-spacer"></div>
        		<div role="main"><h1 id="setting-up-a-codewind-ready-install-of-che">Setting up a Codewind-ready install of Che</h1>

<p>To setup a Codewind-ready install of Che, follow these instructions. Alternatively, the install script at https://github.com/eclipse/codewind-che-plugin/tree/master/setup/install_che can be used instead.</p>

<h1 id="table-of-contents">Table of Contents</h1>
<ol>
  <li><a href="#prerequisites">Prerequisites</a></li>
  <li><a href="#installing-che-with-the-operator">Installing Che with the operator</a></li>
  <li><a href="#setting-up-okd-and-openshift">Setting up OKD and OpenShift</a></li>
  <li><a href="#setting-up-other-kubernetes">Setting up other Kubernetes</a></li>
  <li><a href="#after-installing-che">After installing Che</a></li>
  <li><a href="#creating-the-codewind-workspace">Creating the Codewind workspace</a></li>
  <li><a href="#updating-the-version">Updating the version</a></li>
</ol>

<h2 id="prerequisites">Prerequisites</h2>
<ul>
  <li>Set up the PersistentVolume (PV) with either Network File System (NFS) or GlusterFS.
    <ul>
      <li>For NFS, if running on IBM Cloud Private, follow these instructions:<a href="https://www.ibm.com/developerworks/community/blogs/fe25b4ef-ea6a-4d86-a629-6f87ccf4649e/entry/Working_with_storage?lang=en">NFS Storage Install Instructions</a> and use 777 permissions for the folders.</li>
      <li>You do not need to set up the PV for local Kube, such as Minikube, Minishift, Docker Desktop, and others.</li>
    </ul>
  </li>
  <li>Set up the ClusterRole.
    <ul>
      <li><strong>Important:</strong> If you are installing Che with the <code class="highlighter-rouge">deploy_che.sh</code> script for OpenShift, do this step <em>after</em> installing Che.
        <ol>
          <li>Clone the <a href="https://github.com/eclipse/codewind-che-plugin">Codewind Che plug-in repository</a></li>
          <li>Enter the <code class="highlighter-rouge">cd</code> command to go to the <code class="highlighter-rouge">codewind-che-plugin</code> repository.</li>
          <li>Run the <code class="highlighter-rouge">kubectl apply -f setup/install_che/codewind-clusterrole.yaml</code> command to create a cluster role with the required permission.</li>
          <li>Next, run the <code class="highlighter-rouge">kubectl apply -f setup/install_che/codewind-rolebinding.yaml</code> command.</li>
        </ol>
      </li>
    </ul>
  </li>
</ul>

<h2 id="installing-che-with-the-operator">Installing Che with the operator</h2>

<p>For instructions on installing Che with the Che operator, please see the <a href="https://operatorhub.io/operator/eclipse-che">Eclipse Che operator on Operator Hub</a>.</p>

<p><strong>Note:</strong> Complete the following steps before you create your <code class="highlighter-rouge">CheCluster</code> custom resource.</p>

<ol>
  <li>
    <p>Create the <code class="highlighter-rouge">eclipse-codewind</code> cluster role: <code class="highlighter-rouge">kubectl apply -f https://raw.githubusercontent.com/eclipse/codewind-che-plugin/master/setup/install_che/codewind-clusterrole.yaml</code>.</p>
  </li>
  <li>
    <p>Ensure the following fields in your <code class="highlighter-rouge">CheCluster</code> <code class="highlighter-rouge">.yaml</code> file are set:</p>
    <ul>
      <li>The <code class="highlighter-rouge">spec.server.cheWorkspaceClusterRole</code> field is set to <code class="highlighter-rouge">eclipse-codewind</code>, which was created when you previously applied the Codewind ClusterRole.</li>
      <li>The <code class="highlighter-rouge">spec.storage.preCreateSubPaths</code> field is set to <code class="highlighter-rouge">true</code>.</li>
    </ul>
  </li>
</ol>

<h2 id="setting-up-okd-and-openshift">Setting up OKD and OpenShift</h2>

<h3 id="installing-che-with-deployment-scripts">Installing Che with deployment scripts</h3>

<p>If the Che operator was not used to install Eclipse Che, follow these steps instead. Otherwise skip these steps:</p>

<ol>
  <li>Git clone the <a href="https://github.com/eclipse/che">Eclipse Che repository</a>.</li>
  <li>Enter the <code class="highlighter-rouge">cd</code> command to go to the <code class="highlighter-rouge">deploy/openshift</code> directory.</li>
  <li>Deploy Che with <code class="highlighter-rouge">./deploy_che.sh</code>.</li>
  <li>From the <a href="https://github.com/eclipse/codewind-che-plugin">Codewind Che plug-in repository</a> run the <code class="highlighter-rouge">kubectl apply -f setup/install_che/codewind-clusterrole.yaml</code> command to create a cluster role with the required permission.</li>
  <li>From the <a href="https://github.com/eclipse/codewind-che-plugin">Codewind Che plug-in repository</a> run the <code class="highlighter-rouge">kubectl apply -f setup/install_che/codewind-rolebinding.yaml</code> command.</li>
</ol>

<h3 id="enable-privileged-and-root-containers-to-run">Enable privileged and root containers to run</h3>
<p>Codewind is currently required to run as privileged (as it builds container images) and as root. Run the following commands to enable that functionality:</p>
<ol>
  <li>Enter <code class="highlighter-rouge">oc adm policy add-scc-to-group privileged system:serviceaccounts:eclipse-che</code> to enable privileged containers</li>
  <li>Enter <code class="highlighter-rouge">oc adm policy add-scc-to-group anyuid system:serviceaccounts:eclipse-che</code> to enable containers to run as root.</li>
</ol>

<h2 id="setting-up-other-kubernetes">Setting up other Kubernetes</h2>

<h3 id="ibm-cloud-private-set-the-clusterimagepolicy">IBM Cloud Private: Set the ClusterImagePolicy</h3>
<p>If you’re running on IBM Cloud Private, you must add the images that Che uses to the ClusterImagePolicy before deploying Che:</p>
<ol>
  <li>Log in to the IBM Cloud Private cluster.</li>
  <li>Run the <code class="highlighter-rouge">kubectl edit clusterimagepolicy</code> command. Then, add the following lines:
    <div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  - name: gcr.io/*
  - name: docker.io/*
</code></pre></div>    </div>
  </li>
</ol>

<h3 id="step-1-setting-up-the-che-helm-chart">Step 1: Setting up the Che Helm chart</h3>

<p>If the Che operator was not used to install Eclipse Che, follow these steps instead. Otherwise skip these steps:</p>

<ol>
  <li>Clone the <a href="https://github.com/eclipse/che">Che repository</a>.</li>
  <li>Enter the <code class="highlighter-rouge">cd</code> command to go to the <code class="highlighter-rouge">deploy/kubernetes/helm/che</code> directory. Then, edit the <code class="highlighter-rouge">values.yaml</code> file.
    <ul>
      <li>Set up multiuser if you need the multiple users feature: <code class="highlighter-rouge">multiuser: true</code></li>
    </ul>
  </li>
</ol>

<h3 id="step-2-installing-che-with-the-helm-chart">Step 2: Installing Che with the Helm chart</h3>
<p>Clone the <a href="https://github.com/eclipse/che">Che repository</a>.</p>
<ol>
  <li>Enter the <code class="highlighter-rouge">cd</code> command to go to the <code class="highlighter-rouge">deploy/kubernetes/helm/che</code> directory.</li>
  <li>Run the <code class="highlighter-rouge">helm dependency update</code> command.</li>
  <li>Run the following command:
    <div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code> helm upgrade --install che --namespace &lt;ns&gt; \
     --set cheImage=eclipse/che-server:7.0.0 \
     --set global.ingressDomain=&lt;cluster proxy ip&gt;.nip.io \
     --set global.cheWorkspaceClusterRole=eclipse-codewind \
     --set global.cheWorkspacesNamespace=&lt;ns&gt; \
     --set che.workspace.devfileRegistryUrl="https://che-devfile-registry.openshift.io/" \
     --set che.workspace.pluginRegistryUrl="https://che-plugin-registry.openshift.io/v3" ./
</code></pre></div>    </div>
  </li>
</ol>

<p>Append the <code class="highlighter-rouge">--tls</code> flag if the tiller is configured with SSL in your Kubernetes cluster.</p>

<h2 id="after-installing-che">After installing Che</h2>

<h3 id="adding-registries-in-che">Adding registries in Che</h3>
<p>After Che is started and running, add the container registry that will be used with Codewind.</p>
<ul>
  <li>On IBM Cloud Private, push your 
to any Docker registry <em>except</em> the internal Docker registry</li>
  <li>On OpenShift or other Kube platforms, you can push your images to any Docker registry, such as Dockerhub, Quay.io, Google Cloud Registry (GCR), and more.</li>
</ul>

<p>Complete the following instructions to add the registries:</p>
<ul>
  <li>Server: <code class="highlighter-rouge">&lt;registry-to-push-images-to&gt;</code></li>
  <li>Username: <code class="highlighter-rouge">&lt;Your username&gt;</code></li>
  <li>Password: <code class="highlighter-rouge">&lt;Your password&gt;</code></li>
</ul>

<p>For further information on adding deployment registries to Che, consult our <a href="https://www.eclipse.org/codewind/dockerregistry.html">registry documentation</a></p>

<h3 id="optional-hosting-a-devfile-for-creating-the-che-workspace-with-codewind">Optional: Hosting a Devfile for creating the Che workspace with Codewind</h3>

<p>Skip this step if you are using the devfiles that Codewind provides by default. If you wish to host your own devfile, follow these instructions:</p>

<ol>
  <li>Clone the [Codewind Che plug-in repositoryhttps://github.com/eclipse/codewind-che-plugin).</li>
  <li>Make your modifications as you see fit.</li>
  <li>The <code class="highlighter-rouge">devfile.yaml</code> and <code class="highlighter-rouge">meta.yaml</code> files need to be hosted in a location that Che can access, such as Github.</li>
  <li>In <code class="highlighter-rouge">devfile.yaml</code>, modify the <code class="highlighter-rouge">codewind-sidecar</code> and <code class="highlighter-rouge">codewind-theia</code> components so that their ID formats match.
For example, <code class="highlighter-rouge">https://raw.githubusercontent.com/eclipse/codewind-che-plugin/master/plugins/codewind/codewind-sidecar/0.3.0/meta.yaml
</code> and <code class="highlighter-rouge">https://raw.githubusercontent.com/eclipse/codewind-che-plugin/master/plugins/codewind/codewind-theia/0.3.0/meta.yaml
</code> host the <code class="highlighter-rouge">meta.yaml</code> files.</li>
</ol>

<h2 id="creating-the-codewind-workspace">Creating the Codewind workspace</h2>

<h3 id="confirm-the-docker-registry-secrets">Confirm the Docker registry secrets.</h3>
<p>Confirm that you added the docker registry secrets in the Che dashboard. Go to <strong>Administration</strong>&gt;<strong>Add Registry</strong> to check for the secrets.</p>

<h3 id="creating-the-codewind-workspace-with-a-devfile">Creating the Codewind workspace with a Devfile</h3>
<p>The general format for creating a Che workspace via a factory is:</p>
<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>http://&lt;che ingress domain&gt;/f?url=&lt;hosted devfile URL&gt;
</code></pre></div></div>

<p>We provide a ready-to-use devfile with the Codewind plug-ins. Enter the following URL to create a workspace from the devfile:</p>
<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>http://&lt;che ingress domain&gt;/f?url=https://raw.githubusercontent.com/eclipse/codewind-che-plugin/master/devfiles/0.3.0/devfile.yaml
</code></pre></div></div>

<p>For other sample devfiles, see https://github.com/kabanero-io/codewind-templates/tree/master/devfiles</p>

<h3 id="checking-for-the-codewind-pod">Checking for the Codewind pod</h3>
<ol>
  <li>If you are using the Terminal, switch to use the workspace namespace. You can check for the namespace with <code class="highlighter-rouge">kubectl get ns</code>.</li>
  <li>Ensure the projects are cloned into the workspace. You might need to refresh the browser to trigger the clone.</li>
</ol>

<h3 id="configuring-codewind-for-tekton-pipelines">Configuring Codewind for Tekton pipelines</h3>
<p>From your command line, enter the following commands if you want to use existing Tekton installations with Codewind:</p>

<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>oc apply -f setup/install_che/codewind-tektonrole.yaml
oc apply -f setup/install_che/codewind-tektonbinding.yaml
</code></pre></div></div>

<p>For more information about Tekton, see <a href="https://github.com/tektoncd/experimental/blob/master/webhooks-extension/docs/GettingStarted.md">Getting started with the Tekton Dashboard Webhooks Extension</a>.</p>

<h2 id="after-installing-codewind">After installing Codewind</h2>

<h3 id="setting-the-docker-registry">Setting the Docker registry</h3>
<p>Upon creating a Codewind workspace. The container registry to deploy your projects to must be set. When you go to create or add an existing project to Codewind, Codewind will prompt you for the registry. See (Docker registry docs) for guidance on using proper container registries</p>

<p>If you would like to change the registry that’s used at any time, run the <code class="highlighter-rouge">Codewind: Set Deployment Registry</code> command in Theia to dynamically set a new registry for your workspace. <br /></p>

<p><img src="dist/images/che-docs/SetDockerRegistry-1.png" alt="Set deployment registry" height="90px" width="623px" />. <br /></p>

<p><img src="dist/images/che-docs/SetDockerRegistry-2.png" alt="Set deployment registry location" height="85px" width="633px" />. <br /></p>

<p><img src="dist/images/che-docs/SetDockerRegistry-3.png" alt="Test deployment" height="208px" width="801px" />. <br /></p>

<p><strong>Note:</strong> To proceed, you need to have added the registry credentials with Che.</p>
<ul>
  <li>Codewind restarts with the changes added.</li>
</ul>

<h2 id="using-codewind-from-the-che-theia-ide">Using Codewind from the Che Theia IDE</h2>

<h3 id="binding-a-project">Binding a project:</h3>
<p>Go to <strong>View</strong>&gt;<strong>Find Command…</strong>&gt;<strong>Codewind: Add Project</strong>.</p>

<ul>
  <li>Alternative instructions:
    <ul>
      <li>From the sidecar container, run the following command:
<code class="highlighter-rouge">curl -k -H "Content-Type: application/json" -X POST https://codewind-release:9191/api/v1/projects/bind -d '{"name": "microproj", "path": "/microclimate-workspace/microproj", "language": "java", "projectType": "liberty"}'</code></li>
    </ul>
  </li>
</ul>

<h3 id="checking-the-status-of-a-project">Checking the status of a project</h3>
<p>Go to <strong>View</strong>&gt;<strong>Find Command…</strong>&gt;<strong>Codewind: App status</strong>.</p>

<ul>
  <li>Alternative instructions:
    <ul>
      <li>From the sidecar container, run the following command: <code class="highlighter-rouge">curl -k -H "Content-Type: application/json" -X GET https://codewind-release:9191/api/v1/projects</code></li>
    </ul>
  </li>
</ul>

<h3 id="building-a-project">Building a project </h3>
<p>Go to <strong>View</strong>&gt;<strong>Find Command…</strong>&gt;<strong>Codewind: Build</strong>.</p>

<ul>
  <li>Alternative instructions:
    <ul>
      <li>Enter the following command: <code class="highlighter-rouge">curl -k -H "Content-Type: application/json" -X POST https://codewind-release:9191/api/v1/projects/8801a6d0-7805-11e9-b22f-19482c5ffbd6/build -d '{"action": "build"}'</code></li>
    </ul>
  </li>
</ul>

<h2 id="updating-the-version">Updating the version</h2>
<p>Restart the Codewind workspace in Che. Che automatically pulls the newest version of Codewind and the Theia extension.</p>
</div>
        </div>
        
    </div>
    
</div>
<!-- footer row -->
<footer>

<div class="row" id="footer-div-mobile">
        
        <div class="cw_footer_display_flex cw-footer-same-height cw-footer-center">
        <div class="cw_footer_display_icons">
    		<div class="cw-footer-col text-center">
            <div>
                <div>
                    <a href="mailto:codewind-dev@eclipse.org"><img alt="email icon"  title="email icon" src="images/email-icon.svg" class="cw-logo" /></a>
                </div>
            </div>
        </div>
        <div class="cw-footer-col text-center">
            <div>
                <div>
                    <a href="https://twitter.com/EclipseCodewind"><img alt="twitter icon"  title="twitter icon" src="images/twitter-logo.svg" class="cw-logo" /></a>
                </div>
            </div>
        </div>
        
        <div class="cw-footer-col text-center">
            <div>
                <div>
                    <a href="https://github.com/eclipse/codewind"><img alt="github icon"  title="github icon" src="images/github-logo.svg"
                            class="cw-logo" /></a>
                </div>
            </div>
        </div>
        

        <div class=" cw-footer-col text-center">
            <div class="cw-logo-mm" >
                <div class="cw-logo-mm" >
                    <a href="https://mattermost.eclipse.org/eclipse/channels/eclipse-codewind"><img alt="mattermose icon"  title="mattermose icon" src="images/mattermost-logo.png" class="cw-logo-mm" /></a>
                </div>
            </div>
        </div>
        <div class="cw-footer-col text-center">
            <div>
                <div>
                    <a href="https://www.youtube.com/channel/UCnKCVK6RFDyHFqUmXlAhCHQ"><img alt="youtube icon"  title="youtube icon" src="images/youtube-logo-dark.svg"
                            class="cw-logo" /></a>
                </div>
            </div>
        </div>
        
        </div>
        
		</div>
		
    </div>
    
    
    <div class="row" id="footer-div">
        <div class="cw-footer-left">
        		<div class="px-5 cw-font-12>
	        <span class="cw-font-14">Useful Links:</span>
	        <br/><br/>
	        <a class="cw-footer-links" href="http://www.eclipse.org">Eclipse Foundation</a><br/>
	        <a class="cw-footer-links" href="http://www.eclipse.org/legal/privacy.php">Privacy policy</a><br/>
	        <a class="cw-footer-links" href="http://www.eclipse.org/legal/termsofuse.php">Website terms of use</a><br/>
	        <a class="cw-footer-links" href="http://www.eclipse.org/legal/copyright.php">Copyright agent</a><br/>
	        <a class="cw-footer-links" href="http://www.eclipse.org/legal">Legal</a><br/>
	        </div>
	        
        </div>
        <div class="cw-footer-border-right"></div>
        <div class="cw_footer_display_flex cw-footer-same-height cw-footer-center cw-footer-desktop">
        <div class="cw_footer_display_icons">
    		<div class="cw-footer-col text-center">
            <div>
                <div>
                    <a href="mailto:codewind-dev@eclipse.org"><img alt="email icon"  title="email icon" src="images/email-icon.svg" class="cw-logo" /></a>
                </div>
            </div>
        </div>
        <div class="cw-footer-col text-center">
            <div>
                <div>
                    <a href="https://twitter.com/EclipseCodewind"><img alt="twitter icon"  title="twitter icon" src="images/twitter-logo.svg" class="cw-logo" /></a>
                </div>
            </div>
        </div>
        
        <div class="cw-footer-col text-center">
            <div>
                <div>
                    <a href="https://github.com/eclipse/codewind"><img alt="github icon"  title="github icon" src="images/github-logo.svg"
                            class="cw-logo" /></a>
                </div>
            </div>
        </div>
        

        <div class=" cw-footer-col text-center">
            <div class="cw-logo-mm" >
                <div class="cw-logo-mm" >
                    <a href="https://mattermost.eclipse.org/eclipse/channels/eclipse-codewind"><img alt="mattermost icon"  title="mattermost icon" src="images/mattermost-logo.png" class="cw-logo-mm" /></a>
                </div>
            </div>
        </div>
        <div class="cw-footer-col text-center">
            <div>
                <div>
                    <a href="https://www.youtube.com/channel/UCnKCVK6RFDyHFqUmXlAhCHQ"><img alt="youtube icon"   title="youtube icon" src="images/youtube-logo-dark.svg"
                            class="cw-logo" /></a>
                </div>
            </div>
        </div>
        
        </div>
        
		</div>
		<div class="cw-footer-border-right"></div>
		<div class="cw-footer-right cw-footer-same-height cw-footer-vcenter">
		<div class="cw-footer-eclipse-img cw-footer-same-height px-5 ">
	        
		<a href="http://www.eclipse.org">
		<img alt="eclipse icon"  title="eclipse icon" src="images/eclipse.svg"/>
		</a>
	        </div>
		</div>
    </div>
</footer>
<!-- footer row END -->
<!-- Main Col END -->
 <!-- Jquery -->
<script
  src="https://code.jquery.com/jquery-3.4.1.min.js"
  integrity="sha256-CSXorXvZcTkaix6Yvo6HppcZGetbYMGWSFlBw8HfCJo="
  crossorigin="anonymous"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.7/umd/popper.min.js"
    integrity="sha384-UO2eT0CpHqdSJQ6hJty5KVphtPhzWj9WO1clHTMGa3JDZwrnQq4sF86dIHNDz0W1" crossorigin="anonymous">
</script>



<script src="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js"
    integrity="sha384-JjSmVgyd0p3pXB1rRibZUAYoIIy6OrQ6VrjIEaFf/nJGzIxFDsf4x0xIM+B07jRM" crossorigin="anonymous">
</script>


<!-- Font Awesome JS -->
<script defer src="https://use.fontawesome.com/releases/v5.0.13/js/solid.js"
    integrity="sha384-tzzSw1/Vo+0N5UhStP3bvwWPq+uvzCMfrN1fEFe+xBmv1C/AtVX5K0uZtmcHitFZ" crossorigin="anonymous">
</script>
<script defer src="https://use.fontawesome.com/releases/v5.0.13/js/fontawesome.js"
    integrity="sha384-6OIrr52G08NpOFSZdxxz1xdNSndlD4vdcf/q2myIUVO0VsqaGHJsB0RaBE01VTOY" crossorigin="anonymous">
</script>

<script src="js/jquery.matchHeight-min.js"></script>
<script src="js/index.js"></script>
<script src="js/docs.js"></script>

</div>
</body>

</html>