inky ==> linky update (#1767)

## Type of change
<!-- Please be sure to add the appropriate label to your PR. -->
This PR updates docs on Academy to say "linky" in place of "inky". 

### What should this PR do?
<!-- Does this PR resolve an issue? Please include a reference to it.
-->
resolves chainguard-dev/internal#4103

### Why are we making this change?
<!-- What larger problem does this PR address? -->
keep Academy in line with new branding

### What are the acceptance criteria? 
<!-- What should be happening for this PR to be accepted? Please list
criteria. -->
<!-- Do any stakeholders need to be tagged in this review? If so, please
add them. -->
Changes should make sense logically. 

### How should this PR be tested?
<!-- What should your reviewer do to test this PR? Please list steps.
-->
I will be testing out the changes to the getting started guides.
Otherwise I think everything just needs a sanity check.

Signed-off-by: Mark Drake <mark@chainguard.dev>

content/chainguard/administration/custom-idps/azure-ad/index.md

@@ -49,7 +49,7 @@ Next, you can optionally set additional branding for the application by selectin
 
 There, you can set additional metadata for the application, including a Chainguard logo icon here to help your users visually identify this integration. If you'd like, you can use the icon from the [Chainguard Console](https://console.chainguard.dev/logo512.png). The console homepage is [console.chainguard.dev](https://console.chainguard.dev), and our terms of service and private statements can be found at [chainguard.dev/terms-of-service](https://www.chainguard.dev/terms-of-service) and [chainguard.dev/privacy-notice](https://www.chainguard.dev/privacy-notice), respectively.
 
-![Screenshot of the Branding & properties screen with the following settings: Name is set to "Chainguard"; Logo shows the sample Inky logo uploaded; Home page URL is set to "https://console.chainguard.dev"; Terms of service URL is set to "https://www.chainguard.dev/terms-of-service"; and the Privacy statement URL is set to "https://www.chainguard.dev/privacy-notice".](aad-branding.png)
+![Screenshot of the Branding & properties screen with the following settings: Name is set to "Chainguard"; Logo shows the sample Linky logo uploaded; Home page URL is set to "https://console.chainguard.dev"; Terms of service URL is set to "https://www.chainguard.dev/terms-of-service"; and the Privacy statement URL is set to "https://www.chainguard.dev/privacy-notice".](aad-branding.png)
 
 Finally, navigate to the **Certificates & secrets** tab to create a client secret to authenticate the Chainguard platform to Azure Active Directory. Select **New client secret** to add a client secret. In the resulting modal window, add a description and set an expiration date.
 

content/chainguard/administration/custom-idps/ping-id/index.md

@@ -37,7 +37,7 @@ Configure the application as follows:
 * **Icon**: You can optionally add a Chainguard logo icon here to help your users visually identify this integration. If you'd like, you can use the icon from the [Chainguard Console](https://console.chainguard.dev/logo512.png).
 * **Application Type**: Select **OIDC Web App**.
 
-![Screenshot showing the Add Application modal window with the following settings in place: Application Name is set to "Chainguard"; Description reads "Build it right, Build it safe, Build it fast, https://console.chainguard.dev"; the example Inky icon has been uploaded to the Icon field; and the Application Type is set to "OIDC Web App."](ping-2-add-app.png)
+![Screenshot showing the Add Application modal window with the following settings in place: Application Name is set to "Chainguard"; Description reads "Build it right, Build it safe, Build it fast, https://console.chainguard.dev"; the example Linky icon has been uploaded to the Icon field; and the Application Type is set to "OIDC Web App."](ping-2-add-app.png)
 
 After setting these details, click the **Save** button.
 

content/chainguard/administration/iam-organizations/how-to-manage-iam-organizations-in-chainguard.md

@@ -103,10 +103,10 @@ You can also securely distribute the invite link and have users open it in their
 Note that you can tighten the scope of an invite code by including the `--email` and `--ttl` flags when creating the invite.
 
 ```sh
-chainctl iam invite create $ORGANIZATION --email inky@example.com --ttl 24h
+chainctl iam invite create $ORGANIZATION --email linky@example.com --ttl 24h
 ```
 
-In this example, the invitation is scoped to a user with the email address `inky@example.com`. If someone with a different email address tries to use the code it will not work. The `--ttl` option in this example means that the code will expire in 24 hours.
+In this example, the invitation is scoped to a user with the email address `linky@example.com`. If someone with a different email address tries to use the code it will not work. The `--ttl` option in this example means that the code will expire in 24 hours.
 
 
 ## Learn more

content/chainguard/administration/iam-organizations/rolebinding-terraform-gh/index.md

@@ -307,7 +307,7 @@ chainctl auth login
 
 After navigating to the Console or running the login command, they will be presented with the following login flow.
 
-![Screenshot of the default Chainguard login flow. It includes the Inky logo above the words "Welcome. Log in to Chainguard to continue to Chainguard." Below this are three buttons, one reading "Continue with Google", one reading "Continue with GitHUb", and a third reading "Continue with GitLab".](login-flow.png)
+![Screenshot of the default Chainguard login flow. It includes the Linky logo above the words "Welcome. Log in to Chainguard to continue to Chainguard." Below this are three buttons, one reading "Continue with Google", one reading "Continue with GitHUb", and a third reading "Continue with GitLab".](login-flow.png)
 
 There, they must click the **Continue with GitHub** button to continue logging in under their GitHub account. Chainguard will immediately recognize their GitHub account because it is tied to the role-binding you created in the previous step, and they will be able to view the resources associated with the Chainguard organization specified in your Terraform configuration.
 

content/chainguard/chainguard-images/getting-started/nginx/index.md

@@ -65,7 +65,7 @@ Using a text editor of your choice, create a new file `index.html` for the HTML
 nano index.html
 ```
 
-The following HTML file displays an image of Inky alongside a fun octopus fact.
+The following HTML file displays an image of Linky alongside a fun octopus fact.
 
 ```HTML
 <!DOCTYPE html>
@@ -81,7 +81,7 @@ The following HTML file displays an image of Inky alongside a fun octopus fact.
 
 <h2>from the <a href="https://edu.chainguard.dev/" target="_blank">Chainguard Academy</a></h2>
 
-<img src="inky.png" class="corners" width="250px">
+<img src="linky.png" class="corners" width="250px">
 
 <i><h3>Did you know?</h3></i>
 <p>The Wolfi octopus is the world's smallest octopus, weighing in on average at less than a gram!</p>
@@ -133,10 +133,10 @@ p {
 
 After copying the code into the `stylesheet.css` file, save and close it.
 
-Next, you will pull down the `inky.png` file using `curl`. Always [inspect the URL](https://raw.githubusercontent.com/chainguard-dev/edu-images-demos/734e6171ee69f0e0dbac95e6ebc1759ac18bf00a/nginx/data/inky.png) before downloading it to ensure it comes from a safe and trustworthy location.
+Next, you will pull down the `linky.png` file using `curl`. Always [inspect the URL](https://raw.githubusercontent.com/chainguard-dev/edu-images-demos/734e6171ee69f0e0dbac95e6ebc1759ac18bf00a/nginx/data/linky.png) before downloading it to ensure it comes from a safe and trustworthy location.
 
 ```shell
-curl -O https://raw.githubusercontent.com/chainguard-dev/edu-images-demos/734e6171ee69f0e0dbac95e6ebc1759ac18bf00a/nginx/data/inky.png
+curl -O https://raw.githubusercontent.com/chainguard-dev/edu-images-demos/734e6171ee69f0e0dbac95e6ebc1759ac18bf00a/nginx/data/linky.png
 ```
 
 Now, return to the `nginxdemo` directory you made earlier. 
@@ -221,7 +221,7 @@ chmod +wx /opt/homebrew/var/log/nginx/
 
 With the directory permissions updated, you should now be able to initialize the nginx server.
 
-To view the HTML content, navigate to `localhost:8080` in your web browser of choice. You will see a simple landing page with a picture of Inky and a fun fact about the Wolfi octopus.
+To view the HTML content, navigate to `localhost:8080` in your web browser of choice. You will see a simple landing page with a picture of Linky and a fun fact about the Wolfi octopus.
 
 If you make any changes to the files nginx is serving, run `nginx -s reload` in your terminal to allow the changes to render. When you are finished with your website, run `nginx -s quit` to allow nginx to safely shut down.
 
@@ -263,7 +263,7 @@ Once the build is complete, run the image with:
 docker run -d --name nginxcontainer -p 8080:8080 nginx-demo
 ```
 
-The `-d` flag configures our container to run as a background process. The `--name` flag will name our container `nginxcontainer`, making it easy to identify from other containers. The `-p` flag publishes the port that the container listens on to a port on your local machine. This allows us to navigate to `localhost:8080` in a web browser of our choice to view the HTML content served by the container. You should see the same HTML page as before, with Inky and an octopus fun fact.
+The `-d` flag configures our container to run as a background process. The `--name` flag will name our container `nginxcontainer`, making it easy to identify from other containers. The `-p` flag publishes the port that the container listens on to a port on your local machine. This allows us to navigate to `localhost:8080` in a web browser of our choice to view the HTML content served by the container. You should see the same HTML page as before, with Linky and an octopus fun fact.
 
 If you wish to publish to a different port on your machine, such as `1313`, you can do so by altering the command-line argument as shown:
 

content/chainguard/chainguard-images/getting-started/python.md

@@ -158,10 +158,10 @@ tools for production.
 
 We'll start by creating a Python application that will take in an image file and convert it to ANSI escape sequences on the CLI to render an image.
 
-To begin, create a directory for your app. You can use any meaningful name and path that resonates with you, our example will use `inky/`.
+To begin, create a directory for your app. You can use any meaningful name and path that resonates with you, our example will use `linky/`.
 
 ```shell
-mkdir ~/inky/ && cd $_
+mkdir ~/linky/ && cd $_
 ```
 
 We'll first write out the requirements for our app in a new file, for example we named our file `requirements.txt`. You can edit this file in your preferred code editor, in our case we will use Nano.
@@ -177,13 +177,13 @@ setuptools==68.2.2
 climage==0.2.0
 ```
 
-Save the file and we will next create a new file with our python code called `inky.py`. You can edit this file in whatever code editor you would like. We’ll use Nano as an example.
+Save the file and we will next create a new file with our python code called `linky.py`. You can edit this file in whatever code editor you would like. We’ll use Nano as an example.
 
 ```shell
-nano inky.py
+nano linky.py
 ```
 
-Add the following Python code which defines a CLI app that takes in an image file, `inky.png`, and
+Add the following Python code which defines a CLI app that takes in an image file, `linky.png`, and
 prints a representation of that file to the terminal:
 
 ```python
@@ -193,27 +193,27 @@ from climage import convert
 
 def main():
     '''Take in PNG and output as ANSI to terminal'''
-    output = convert('inky.png', is_unicode=True)
+    output = convert('linky.png', is_unicode=True)
     print(output)
 
 if __name__ == "__main__":
     main()
 ```
 
-Next, pull down the `inky.png` image file with `curl`. [Inspect the URL](https://raw.githubusercontent.com/chainguard-dev/edu-images-demos/main/python/inky/inky.png) before downloading it to ensure it is safe to do so. Make sure you are still in the same directory where your `inky.py` script is.
+Next, pull down the `linky.png` image file with `curl`. [Inspect the URL](https://raw.githubusercontent.com/chainguard-dev/edu-images-demos/main/python/linky/linky.png) before downloading it to ensure it is safe to do so. Make sure you are still in the same directory where your `linky.py` script is.
 
 ```shell
-curl -O https://raw.githubusercontent.com/chainguard-dev/edu-images-demos/main/python/inky/inky.png
+curl -O https://raw.githubusercontent.com/chainguard-dev/edu-images-demos/main/python/linky/linky.png
 ```
 
 If you have python and pip installed in your local environment, you can now install the dependencies with `pip` and run our program. Don't worry if you don't have python installed, you can simply skip this step and move onto the Dockerfile.
 
 ```shell
 pip install -r requirements.txt
-python inky.py
+python linky.py
 ```
 
-You'll receive a representation of the Chainguard Inky logo on the command line. With your demo application ready, you're ready to move onto the container stage.
+You'll receive a representation of the Chainguard Linky logo on the command line. With your demo application ready, you're ready to move onto the container stage.
 
 ### Step 2: Creating the Dockerfile
 
@@ -233,7 +233,7 @@ The following Dockerfile will:
 
 1. Start a new build stage based on the `python:latest-dev` image and call it `builder`;
 2. Create a new virtual environment to cleanly hold the application's dependencies;
-2. Copy `requirements.txt` from the current directory to the `/inky` location in the container;
+2. Copy `requirements.txt` from the current directory to the `/linky` location in the container;
 3. Run `pip install --no-cache-dir -r requirements.txt` to install dependencies;
 4. Start a new build stage based on the `python:latest` image;
 5. Copy the dependencies in the virtual environment from the builder stage, and the source code from
@@ -248,43 +248,43 @@ FROM cgr.dev/chainguard/python:latest-dev as builder
 ENV LANG=C.UTF-8
 ENV PYTHONDONTWRITEBYTECODE=1
 ENV PYTHONUNBUFFERED=1
-ENV PATH="/inky/venv/bin:$PATH"
+ENV PATH="/linky/venv/bin:$PATH"
 
-WORKDIR /inky
+WORKDIR /linky
 
-RUN python -m venv /inky/venv
+RUN python -m venv /linky/venv
 COPY requirements.txt .
 
 RUN pip install --no-cache-dir -r requirements.txt
 
 FROM cgr.dev/chainguard/python:latest
 
-WORKDIR /inky
+WORKDIR /linky
 
 ENV PYTHONUNBUFFERED=1
 ENV PATH="/venv/bin:$PATH"
 
-COPY inky.py inky.png ./
-COPY --from=builder /inky/venv /venv
+COPY linky.py linky.png ./
+COPY --from=builder /linky/venv /venv
 
-ENTRYPOINT [ "python", "/inky/inky.py" ]
+ENTRYPOINT [ "python", "/linky/linky.py" ]
 ```
 
 Save the file when you’re finished.
 
 You can now build the image. If you receive a permission error, try running under `sudo`.
 
 ```shell
-docker build -t inky .
+docker build -t linky .
 ```
 
 Once the build is finished, run the image with:
 
 ```shell
-docker run --rm inky
+docker run --rm linky
 ```
 
-And you should get output similar to what you got before, with a printed Inky on the command line.
+And you should get output similar to what you got before, with a printed Linky on the command line.
 
 ## Advanced Usage
 

content/chainguard/chainguard-images/getting-started/ruby.md

@@ -145,10 +145,10 @@ This demo will use the [rainbow](https://rubygems.org/gems/rainbow) Ruby gem to
 
 ### Step 1: Setting up the Application
 
-First, create a directory for your app. Here we'll use `inky-says`:
+First, create a directory for your app. Here we'll use `linky-says`:
 
 ```shell
-mkdir ~/inky-says && cd ~/inky-says
+mkdir ~/linky-says && cd ~/linky-says
 ```
 
 Then, set up your Gemfile:
@@ -166,21 +166,21 @@ gem 'rainbow'
 ```
 Save and close the file.
 
-Next, create a new Ruby script file called `inky.rb`:
+Next, create a new Ruby script file called `linky.rb`:
 
 ```shell
-nano inky.rb
+nano linky.rb
 ```
 
-The following code outputs a colorful quote provided at runtime, incorporating an ASCII representation of Inky that is pulled from an `inky.txt` file located at the same directory as the ruby script. The printed quote colors alternate randomly between purple and magenta.
+The following code outputs a colorful quote provided at runtime, incorporating an ASCII representation of Linky that is pulled from an `linky.txt` file located at the same directory as the ruby script. The printed quote colors alternate randomly between purple and magenta.
 
 ```ruby
 #!/usr/bin/env ruby
 
 require 'rainbow'
 Rainbow.enabled = true
 
-class Inky
+class Linky
   def says(message = "Hello World")
     colors = [:purple, :magenta]
     words = message.split(" ")
@@ -191,24 +191,24 @@ class Inky
     end
 
     print "\n"
-    puts File.readlines('inky.txt')
+    puts File.readlines('linky.txt')
   end
 end
 
 if __FILE__ == $0
-  inky = Inky.new
+  linky = Linky.new
   inputArray = ARGV
   message = inputArray.length > 0 ? inputArray.join(' ') : "Hello Wolfi"
-  inky.says(message)
+  linky.says(message)
 end
 ```
 
-Copy this code to your `inky.rb` script, then save and close the file.
+Copy this code to your `linky.rb` script, then save and close the file.
 
-Next, pull down the ASCII `inky.txt` file with `curl`. You can [inspect the file contents](https://raw.githubusercontent.com/chainguard-dev/edu-images-demos/main/ruby/inky-says/inky.txt) before downloading it to ensure it is safe to do so. Make sure you are still in the same directory where your `inky.rb` script is.
+Next, pull down the ASCII `linky.txt` file with `curl`. You can [inspect the file contents](https://raw.githubusercontent.com/chainguard-dev/edu-images-demos/main/ruby/linky-says/linky.txt) before downloading it to ensure it is safe to do so. Make sure you are still in the same directory where your `linky.rb` script is.
 
 ```shell
-curl -O https://raw.githubusercontent.com/chainguard-dev/edu-images-demos/main/ruby/inky-says/inky.txt
+curl -O https://raw.githubusercontent.com/chainguard-dev/edu-images-demos/main/ruby/linky-says/linky.txt
 ```
 
 With everything in place, you can now work on the Dockerfile that will install the application dependencies and execute your Ruby script.
@@ -231,8 +231,8 @@ The following Dockerfile will:
 5. Start a new build stage based on the `cgr.dev/chainguard/ruby:latest` image;
 6. Set up environment variables that define the default location of installed Gems;
 7. Copy build artifacts from `builder` and into the final image
-8. Copy the `inky.rb` and `inky.txt` files into the final image
-9. Set up the application entry point as `ruby inky.rb`.
+8. Copy the `linky.rb` and `linky.txt` files into the final image
+9. Set up the application entry point as `ruby linky.rb`.
 
 Copy this content to your own `Dockerfile`:
 
@@ -250,23 +250,23 @@ ENV GEM_HOME=/work/vendor
 ENV GEM_PATH=${GEM_PATH}:/work/vendor
 
 COPY --from=builder /work/ /work/
-COPY inky.rb inky.txt /work/
+COPY linky.rb linky.txt /work/
 
-ENTRYPOINT [ "ruby", "inky.rb" ]
+ENTRYPOINT [ "ruby", "linky.rb" ]
 
 ```
 Save the file when you're finished.
 
 You can now build the image with:
 
 ```shell
-docker build . -t inky-says
+docker build . -t linky-says
 ```
 
 Once the build is finished, run the image with:
 
 ```shell
-docker run --rm inky-says Wolfi says hi
+docker run --rm linky-says Wolfi says hi
 ```
 
 And you should get output like this:
@@ -291,10 +291,10 @@ And you should get output like this:
 
 ```
 
-If you inspect the image with a `docker image inspect inky-says`, you'll notice that it has only **three** layers, thanks to the use of a multi-stage Docker build.
+If you inspect the image with a `docker image inspect linky-says`, you'll notice that it has only **three** layers, thanks to the use of a multi-stage Docker build.
 
 ```shell
-docker image inspect inky-says
+docker image inspect linky-says
 ```
 ```shell
 ...

content/chainguard/chainguard-registry/pull-through-guides/artifactory-pull-through/index.md

@@ -65,7 +65,7 @@ After clicking the **Set Up Docker Client** button, a modal window will appear f
 The first will be a `docker login` command similar to the following example. Copy this command and run it in your terminal.
 
 ```sh
-docker login -u<inky@chainguard.dev> <myproject>.jfrog.io
+docker login -u<linky@chainguard.dev> <myproject>.jfrog.io
 ```
 
 After running this command, you'll be prompted to enter a password. Copy the token from the second code block and paste it into your terminal.
@@ -130,7 +130,7 @@ After clicking the **Set Up Docker Client** button, a modal window will appear f
 The first will be a `docker login` command similar to the following example. Copy this command and run it in your terminal.
 
 ```sh
-docker login -u<inky@chainguard.dev> <myproject>.jfrog.io
+docker login -u<linky@chainguard.dev> <myproject>.jfrog.io
 ```
 
 Be sure to include your own username and Artifactory instance.