View source for VS Code Remote Development

__NOTOC__
This guide provides information on running VS Code Remote Development on HiPerGator, including running Jupyter notebooks. This has been updated in December 2022 when Microsoft [https://code.visualstudio.com/blogs/2022/12/07/remote-even-better integrated Remote Development into VS Code].

==Introduction==
Why might you want to do this?

* VS Code is a nice IDE with many great features, including [https://github.com/features/copilot GitHub Copilot] (which most UF users should be able to access for free--via either student or faculty/staff [https://education.github.com/ GitHub Education] plans).
* [https://www.rc.ufl.edu/get-started/hipergator/ HiPerGator] provides a powerful compute environment with thousands of cores, petabytes of storage, and powerful GPUs.
* But, combining the two can be problematic...
** Remote SSH setup is complicated by MFA and the need to tunnel into a compute server with your running job. This can be worked out, but is a bit cumbersome.
** You can accidentally end up running scripts on the login servers and have your account suspended if you connect via the [https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-ssh remote ssh] extension and run a notebook or other code outside of [[Development_and_Testing]] limits as those processes would be running on login nodes.
** Running VS Code on HiPerGator through OOD is kind of slow and limiting as vscode environment module updates can lag behind the rapid vscode release schedule.
* With VS Code Remote Development, you can startup the server within an interactive job with whatever resources you have requested and connect to it in your web browser from [https://vscode.dev/ https://vscode.dev/]. There are no MFA issues and you can install your desired extensions, connect to GitHub Copilot, run and debug your code easily!

==VSCode Setup==
===Using hpg env module===
If you don't mind staying on Research Computing's update schedule, you can put the following commands into the job script that starts the vscode server and the tunnel in a SLURM job:

 export XDG_RUNTIME_DIR=${SLURM_TMPDIR}
 module load vscode
 code tunnel

===Personal VSCode install===

This may become somewhat optional as Research Computing updates VS Code, but this does give you full control over the version to use.

If missing ~/bin, create it with
 mkdir ~/bin

# Download the x64 CLI for Linux package from the [https://code.visualstudio.com/#alt-downloads VS Code Downloads site ].
# Transfer the download to HiPerGator.
# Extract the tar.gz file and copy the binary to ~/bin:

 tar -xvf vscode_cli_alpine_x64_cli.tar.gz
 cp code ~/bin/

== Test VSCode Tunnel==

See [https://help.rc.ufl.edu/doc/Development_and_Testing this page for information on development sessions HiPerGator], but something like the following should work: 

# <code>srundev</code> and wait for the session to start.
# Start VS Code Server: <code>code tunnel</code>
# Use ''''Ctrl-C'''' key combination to stop the <code>tunnel</code> process.
# Exit the srun session: <code>exit</code>

== Regular Use ==

Now that VS Code is setup, it should be relatively easy to start. For the most part, the process is:

* Log into HiPerGator
* Submit a tunnel job. E.g. job script (adjust the resource request as needed for your analysis):

CPU only job
<pre>
#!/bin/bash
#SBATCH --job-name=vscode
#SBATCH --nodes=1
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=2
#SBATCH --mem=8gb
#SBATCH --time=08:00:00 # example 8 hrs
hostname;date;pwd
export XDG_RUNTIME_DIR=${SLURM_TMPDIR}
# HPG install of vscode. Comment the next line out with '#' if using a personal install
module load vscode
# Both hpg and personal install of vscode
code tunnel
</pre>

GPU job
<pre>
#!/bin/bash
#SBATCH --job-name=vscode
#SBATCH --partition=gpu
#SBATCH --gpus=a100:1
#SBATCH --nodes=1
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=2
#SBATCH --mem=8gb
#SBATCH --time=08:00:00 # example 8 hrs
hostname;date;pwd
export XDG_RUNTIME_DIR=${SLURM_TMPDIR}
# HPG install of vscode. Comment the next line out with '#' if using a personal install
module load vscode
# Both hpg and personal install of vscode
code tunnel
</pre>

For an interactive test:
'''Note: srun session will exit if your network connection to HPG is broken or if you exit.
<pre>
# Start a development session, [https://help.rc.ufl.edu/doc/GPU_Access#Interactive_Access requesting GPUs if needed], and other resources for the time you want to work.
#* For example, for a session requesting 4 cores, 15GB of RAM, an A100 GPU for 1 hour: <code>'''srun -c 4 --mem 15gb -p gpu --gres gpu:a100:1 -t 60 --pty bash -i'''</code>
# For Jupyter notebooks it is important to:
#* Load Jupyter  and the module you need for the kernel you want to use, e.g. for Tensorflow: <code>module load jupyter tensorflow/2.7.0</code>
#* Export the <code>XDG_RUNTIME_DIR</code> to set temp directory (otherwise it tries to use <code>/run/user/</code>, which you can't be written to!): <code>export XDG_RUNTIME_DIR=${SLURM_TMPDIR}</code>
# Start VS Code tunnel: <code>code tunnel</code>
#*This can all be done with this line: <code>'''module load jupyter tensorflow/2.7.0; export XDG_RUNTIME_DIR=${SLURM_TMPDIR}; code tunnel'''</code>
</pre>

==Connect To The Tunnel==
* Find the authentication information. Look at the SLURM job log file e.g. with 'less slurm-JOBID.out'. At the top you will see text similar to the following example
<pre>
* Visual Studio Code Server
*
* By using the software, you agree to
* the Visual Studio Code Server License Terms (https://aka.ms/vscode-server-license) and
* the Microsoft Privacy Statement (https://privacy.microsoft.com/en-US/privacystatement).
*
[2024-02-19 16:57:03] info Using Github for authentication, run `code tunnel user login --provider <provider>` option to change this.
To grant access to the server, please log into https://github.com/login/device and use code 14AJ-AYFD
[2024-02-19 17:08:11] info Creating tunnel with the name: c0700a-s4ufhpc

Open this link in your browser https://vscode.dev/tunnel/c0700a-s4ufhpc
</pre>

* Go either to the link shown in the above example
or go to [https://vscode.dev/ https://vscode.dev/] and click on the 'Connect to tunnel' button.
* Authenticate with your GitHub account using the above code.
* Connect to the URL provided in your browser.
* Once you open VS Code in the browser, open the command palette (ctrl+shift+p) and select the appropriate Jupyter Interpreter.  
* Code away!