added solving-problems-with-o11y-cloud workshop and updated docker details in docker-k8s-otel workshop

Author: dmitchsplunk

content/en/ninja-workshops/8-docker-k8s-otel/2-deploy-collector.md

@@ -114,5 +114,5 @@ Where do we find the configuration that is used by this collector?
 
 It's available in the `/etc/otel/collector` directory.  Since we installed the 
 collector in `agent` mode, the collector configuration can be found in the 
-`agent_config.yaml file`. 
+`agent_config.yaml` file. 
 

content/en/ninja-workshops/8-docker-k8s-otel/4-instrument-app-with-otel.md

@@ -13,25 +13,12 @@ using the NuGet packages.
 We'll start by downloading the latest `splunk-otel-dotnet-install.sh` file, 
 which we'll use to instrument our .NET application:
 
-{{< tabs >}}
-{{% tab title="Script" %}}
-
 ``` bash
 cd ~/workshop/docker-k8s-otel/helloworld
 
 curl -sSfL https://github.com/signalfx/splunk-otel-dotnet/releases/latest/download/splunk-otel-dotnet-install.sh -O
 ```
 
-{{% /tab %}}
-{{% tab title="Example Output" %}}
-
-``` bash
-TBD
-```
-
-{{% /tab %}}
-{{< /tabs >}}
-
 Refer to [Install the Splunk Distribution of OpenTelemetry .NET manually](https://docs.splunk.com/observability/en/gdi/get-data-in/application/otel-dotnet/instrumentation/instrument-dotnet-application.html#install-the-splunk-distribution-of-opentelemetry-net-manually)
 for further details on the installation process.
 
@@ -78,23 +65,29 @@ environment within Splunk Observability Cloud:
 export OTEL_RESOURCE_ATTRIBUTES=deployment.environment=otel-$INSTANCE
 ```
 
-## A Challenge For You 
 
-Before starting our .NET application with the instrumentation, there's a challenge for you. 
+## Run the Application with Instrumentation
+
+We can run the application as follows: 
+
+```
+dotnet run
+```
+
+## A Challenge For You
 
-How can we see what traces are being exported by the .NET application?  (i.e. on our Linux instance
-rather than within Observability Cloud)? 
+How can we see what traces are being exported by the .NET application from our Linux instance?
 
 <details>
   <summary><b>Click here to see the answer</b></summary>
 
-There are two ways we can do this: 
+There are two ways we can do this:
 
 1. We could add `OTEL_TRACES_EXPORTER=otlp,console` at the start of the `dotnet run` command, which ensures that traces are both written to collector via OTLP as well as the console.
 ``` bash
 OTEL_TRACES_EXPORTER=otlp,console dotnet run 
 ```
-2. Alternatively, we could add the debug exporter to the collector configuration, and add it to the traces pipeline, which ensures the traces are written to the collector logs. 
+2. Alternatively, we could add the debug exporter to the collector configuration, and add it to the traces pipeline, which ensures the traces are written to the collector logs.
 
 ``` yaml
 exporters:
@@ -112,16 +105,9 @@ service:
 ```
 </details>
 
+## Access the Application
 
-## Run the Application with Instrumentation
-
-We can run the application as follows: 
-
-```
-dotnet run
-```
-
-Once it's running, use a second SSH terminal and access the application using curl:
+Once the application is running, use a second SSH terminal and access it using curl:
 
 ``` bash
 curl http://localhost:8080/hello

content/en/ninja-workshops/8-docker-k8s-otel/5-dockerize-app.md

@@ -48,7 +48,81 @@ What does all this mean?  Let's break it down.
 
 ## Walking through the Dockerfile 
 
-TODO 
+We've used a multi-stage Dockerfile for this example, which separates the Docker image creation process into the following stages: 
+
+* Base
+* Build
+* Publish
+* Final
+
+While a multi-stage approach is more complex, it allows us to create a 
+lighter-weight runtime image for deployment.  We'll explain the purpose of 
+each of these stages below. 
+
+### The Base Stage
+
+The base stage defines the user that will 
+be running the app, the working directory, and exposes 
+the port that will be used to access the app. 
+It's based off of Microsoft's `mcr.microsoft.com/dotnet/aspnet:8.0` image: 
+
+``` dockerfile
+FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
+USER app
+WORKDIR /app
+EXPOSE 8080
+```
+
+Note that the `mcr.microsoft.com/dotnet/aspnet:8.0` image includes the .NET runtime only, 
+rather than the SDK, so is relatively lightweight. It's based off of the Debian 12 Linux 
+distribution.  You can find more information about the ASP.NET Core Runtime Docker images 
+in [GitHub](https://github.com/dotnet/dotnet-docker/blob/main/README.aspnet.md). 
+
+### The Build Stage
+
+The next stage of the Dockerfile is the build stage.  For this stage, the 
+`mcr.microsoft.com/dotnet/sdk:8.0` image is used, which is also based off of 
+Debian 12 but includes the full [.NET SDK](https://github.com/dotnet/dotnet-docker/blob/main/README.sdk.md) rather than just the runtime.  
+
+This stage copies the application code to the build image and then 
+uses `dotnet build` to build the project and its dependencies into a 
+set of `.dll` binaries: 
+
+``` dockerfile
+FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
+ARG BUILD_CONFIGURATION=Release
+WORKDIR /src
+COPY ["helloworld.csproj", "helloworld/"]
+RUN dotnet restore "./helloworld/./helloworld.csproj"
+WORKDIR "/src/helloworld"
+COPY . .
+RUN dotnet build "./helloworld.csproj" -c $BUILD_CONFIGURATION -o /app/build
+```
+
+### The Publish Stage
+
+The third stage is publish, which is based on build stage image rather than a Microsoft image.  In this stage, `dotnet publish` is used to 
+package the application and its dependencies for deployment: 
+
+``` dockerfile
+FROM build AS publish
+ARG BUILD_CONFIGURATION=Release
+RUN dotnet publish "./helloworld.csproj" -c $BUILD_CONFIGURATION -o /app/publish /p:UseAppHost=false
+```
+
+### The Final Stage 
+
+The fourth stage is our final stage, which is based on the base 
+stage image (which is lighter-weight than the build and publish stages). It copies the output from the publish stage image and 
+defines the entry point for our application: 
+
+``` dockerfile
+FROM base AS final
+WORKDIR /app
+COPY --from=publish /app/publish .
+
+ENTRYPOINT ["dotnet", "helloworld.dll"]
+```
 
 ## Build a Docker Image
 

content/en/ninja-workshops/8-docker-k8s-otel/6-add-instrumentation-to-dockerfile.md

@@ -20,10 +20,17 @@ After the .NET application is built in the Dockerfile, we want to:
 * Download the Splunk OTel .NET installer
 * Install the distribution
 
-We can add the following to the Dockerfile to do so: 
+We can add the following to the build stage of the Dockerfile to do so: 
 
 ``` dockerfile
-RUN dotnet build "./diceroll-app.csproj" -c $BUILD_CONFIGURATION -o /app/build
+FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
+ARG BUILD_CONFIGURATION=Release
+WORKDIR /src
+COPY ["helloworld.csproj", "helloworld/"]
+RUN dotnet restore "./helloworld/./helloworld.csproj"
+WORKDIR "/src/helloworld"
+COPY . .
+RUN dotnet build "./helloworld.csproj" -c $BUILD_CONFIGURATION -o /app/build
 
 # Add dependencies for splunk-otel-dotnet-install.sh
 RUN apt-get update && \
@@ -36,14 +43,13 @@ RUN curl -sSfL https://github.com/signalfx/splunk-otel-dotnet/releases/latest/do
 RUN sh ./splunk-otel-dotnet-install.sh
 ```
 
-Next, we'll update the Dockerfile to make the following changes to the final image: 
+Next, we'll update the final stage of the Dockerfile with the following changes: 
 
 * Copy the /root/.splunk-otel-dotnet/ from the build image to the final image 
 * Copy the entrypoint.sh file as well 
 * Set the `OTEL_SERVICE_NAME` and `OTEL_RESOURCE_ATTRIBUTES` environment variables 
 * Set the `ENTRYPOINT` to `entrypoint.sh` 
 
-
 > Note: replace `$INSTANCE` in your Dockerfile with your instance name,
 > which can be determined by running `echo $INSTANCE`.
 
@@ -83,6 +89,21 @@ with the following content:
 exec "$@"
 ```
 
+The `entrypoint.sh` script is required for sourcing environment variables from the instrument.sh script, 
+which is included with the instrumentation. This ensures the correct setup of environment variables 
+for each platform.
+
+> You may be wondering, why can't we just include the following command in the Dockerfile to do this, 
+> like we did when activating OpenTelemetry .NET instrumentation on our Linux host? 
+> ``` dockerfile
+> RUN . $HOME/.splunk-otel-dotnet/instrument.sh
+> ```
+> The problem with this approach is that each Dockerfile RUN step runs a new container and a new shell. 
+> If you try to set an environment variable in one shell, it will not be visible later on.
+> This problem is resolved by using an entry point script, as we've done here. 
+> Refer to this [Stack Overflow post](https://stackoverflow.com/questions/55921914/how-to-source-a-script-with-environment-variables-in-a-docker-build-process) 
+> for further details on this issue. 
+
 ## Build the Docker Image 
 
 Let's build a new Docker image that includes the OpenTelemetry .NET instrumentation: 

content/en/ninja-workshops/8-docker-k8s-otel/_index.md

@@ -6,7 +6,7 @@ archetype: chapter
 time: 2 minutes
 authors: ["Derek Mitchell"]
 description: By the end of this workshop you'll have gotten hands-on experience instrumenting a .NET application with OpenTelemetry, then Dockerizing the application and deploying it to Kubernetes.  You’ll also gain experience deploying the OpenTelemetry collector using Helm, customizing the collector configuration, and troubleshooting collector configuration issues.
-
+draft: true
 ---
 
 In this workshop, you'll get hands-on experience with the following: 

content/en/ninja-workshops/9-solving-problems-with-o11y-cloud/_index.md

@@ -0,0 +1,26 @@
+---
+title: Solving Problems with O11y Cloud
+linkTitle: Solving Problems with O11y Cloud
+weight: 9
+archetype: chapter
+time: 2 minutes
+authors: ["Derek Mitchell"]
+description: By the end of this workshop you'll have gotten hands-on experience deploying the OpenTelemetry Collector, instrumenting an application with OpenTelemetry, and using Troubleshooting MetricSets and Tag Spotlight to determine the root cause of an issue. 
+draft: true
+---
+
+In this workshop, you'll get hands-on experience with the following:
+
+* Deploying the **OpenTelemetry Collector** and customizing the collector config
+* Deploy an application and instrumenting it with **OpenTelemetry**
+* Creating a Troubleshooting MetricSet
+* Troubleshoot a problem and determining root cause using **Tag Spotlight**
+
+Let's get started!
+
+{{% notice title="Tip" style="primary"  icon="lightbulb" %}}
+The easiest way to navigate through this workshop is by using:
+
+* the left/right arrows (**<** | **>**) on the top right of this page
+* the left (◀️) and right (▶️) cursor keys on your keyboard
+  {{% /notice %}}