> ## Documentation Index > Fetch the complete documentation index at: https://docs.domino.ai/llms.txt > Use this file to discover all available pages before exploring further. # Deploy your R model After you have developed your model and deemed it good enough to be useful, you will want to deploy it. There is no single deployment method that is best for all models. Therefore, Domino offers four different deployment options. One may fit your needs better than the others depending on your use case. The available deployment methods are: * Scheduled reports * Launchers * Web applications * Domino endpoints The remaining sections of this tutorial are not dependent on each other. For example, you will not need to complete the **Scheduled report** section to understand and complete the **Web application** section. ## Compute Environments In our previous section, Step 5, we installed the Prophet package in Rstudio in order to train the model. In Domino, any package installed in one work session will not persist to another. In order to avoid having to re-install Prophet each time we need it, you can add it to a custom compute environment. 1. Create a new compute environment. 1. Go to the Environments page in Domino. 2. Click **Create Environment**. 3. Click **Edit Definition**. 4. In the **Dockerfile Instructions** section, enter the following: ```dockerfile theme={null} RUN R --no-save -e "install.packages(c('prophet'))" ``` 5. Scroll to the bottom of the page and click **Build**. This will start the creation of your new compute environment. These added packages will now be permanently installed into your environment and be ready whenever you start a job or workspace session with this environment selected. 6. Go back to your project page and go to the Settings page. 7. Select your newly created environment from the **Compute Environments** menu. If you want to learn more about how to customize your environment, see the [Environments](/cloud/platform-capabilities/core-concepts/compute-environments/manage-compute-environments) tutorials. You can also learn more about what’s included in our default environment, the [Domino Standard Environment](/cloud/platform-capabilities/core-concepts/compute-environments/manage-compute-environments/2-domino-standard-environments#domino-standard-environment-dse). ## Scheduled reports The [Scheduled Jobs](/cloud/platform-capabilities/core-concepts/jobs/schedule-a-job) feature in Domino allows you to run a script on a regular basis. In Domino, using the R package knitr, you can blend text, code, and plots in an RMarkdown to create attractive HTML or pdf reports automatically. In our case, we can imagine that each day we receive new data on power usage and want to email out a visualization of the latest data daily. 1. [Start](/cloud/getting-started/for-modelers-and-builders/get-started-r/3-start-workspace) a new Rstudio session. 2. Create a new Rmarkdown file named `power_report.Rmd` and select HTML as our desired output. 3. Rstudio automatically creates a sample Rmarkdown file for you, but you can replace it entirely with the following which reuses code from our `power.R` script from step 5. ````r theme={null} title: "Power_Report" output: html_document --- ```{r setup, include=FALSE} knitr::opts_chunk$set(echo = TRUE) library(tidyverse) library(lubridate) col_names <- c('HDF', 'date', 'half_hour_increment', 'CCGT', 'OIL', 'COAL', 'NUCLEAR', 'WIND', 'PS', 'NPSHYD', 'OCGT', 'OTHER', 'INTFR', 'INTIRL', 'INTNED', 'INTEW', 'BIOMASS', 'INTEM') df <- read.csv('data.csv', header = FALSE, col.names = col_names, stringsAsFactors = FALSE) #remove the first and last row df <- df[-1,] df <- df[-nrow(df),] #Tidy the data df_tidy <- df %>% gather('CCGT', 'OIL', 'COAL', 'NUCLEAR', 'WIND', 'PS', 'NPSHYD', 'OCGT', 'OTHER', 'INTFR', 'INTIRL', 'INTNED', 'INTEW', 'BIOMASS', 'INTEM', key="fuel", value="megawatt") ``` ```` **R Markdown** Combining R Markdown, Knitr and Domino allows you to create attractive scheduled reports that mix text, code and plots. ````r theme={null} ```{r, echo=FALSE, warning=FALSE} df_tidy <- df_tidy %>% mutate(datetime=as.POSIXct(as.Date(date, "%Y%m%d"))+minutes(30*(half_hour_increment-1))) print(head(df_tidy)) ``` ```` **Including Plots** You can also embed plots, for example: ````r theme={null} ```{r, echo=FALSE} p <- ggplot(data=df_tidy, aes(x=datetime, y=megawatt, group=fuel)) + geom_line(aes(color=fuel)) print(p) ``` ```` 4. With your new Rmarkdown file, you can "knit" this into an html file and preview it directly in Domino by hitting the "Knit" button. 5. To create a repeatable report, you must create a script that you can schedule that will automatically render your Rmarkdown file to html. Start by creating a new R script named `render.R` with the following code: ```r theme={null} rmarkdown::render("power_report.Rmd") ``` 6. Save your files and \*Stop and Commit() your workspace. 7. Go to the Scheduled Jobs page. 8. Enter the file that you want to run. This will be the `render.R` script you created earlier. 9. Select how often and when to run the file. 10. Enter emails of people to send the resulting file(s) to. 11. Click **Schedule**. To discover more tips on how to customize the resulting email, see [Set Notification Preferences](/cloud/platform-capabilities/core-concepts/jobs/customize-job-results) for more information. ## Launchers Launchers are simple web forms that allow users to run templatized scripts. They are especially useful if your script has command line arguments that dynamically change the way the script executes. For heavily customized script, those command line arguments can quickly get complicated. Launcher allows you to expose all of that as a simple web form. Typically, we parameterize script files (that is, files that end in `.py`, `.R`, or `.sh`). Since we have been working with an R script until now, we will parameterize and reuse our R script that we created when we [developed the R model](/cloud/getting-started/for-modelers-and-builders/get-started-r/5-develop-model). To do so, we will insert a few new lines of code into a copy of the R script, and configure a Launcher. 1. Parameterize your R script by setting it to take command line arguments: 1. [Start](/cloud/getting-started/for-modelers-and-builders/get-started-r/3-start-workspace) an Rstudio session. 2. Create script named `Power_for_Launcher.R` with the following: ```r theme={null} library(tidyverse) library(lubridate) #Pass in command line arguments args <- commandArgs(trailingOnly = TRUE) fuel_type <- args[1] col_names <- c('HDF', 'date', 'half_hour_increment', 'CCGT', 'OIL', 'COAL', 'NUCLEAR', 'WIND', 'PS', 'NPSHYD', 'OCGT', 'OTHER', 'INTFR', 'INTIRL', 'INTNED', 'INTEW', 'BIOMASS', 'INTEM') df <- read.csv('data.csv', header = FALSE, col.names = col_names, stringsAsFactors = FALSE) #remove the first and last row df <- df[-1,] df <- df[-nrow(df),] #Tidy the data df_tidy <- df %>% gather('CCGT', 'OIL', 'COAL', 'NUCLEAR', 'WIND', 'PS', 'NPSHYD', 'OCGT', 'OTHER', 'INTFR', 'INTIRL', 'INTNED', 'INTEW', 'BIOMASS', 'INTEM', key="fuel", value="megawatt" ) #Create a new column datetime that represents the starting datetime of the measured increment. df_tidy <- df_tidy %>% mutate(datetime=as.POSIXct(as.Date(date, "%Y%m%d"))+minutes(30*(half_hour_increment-1))) #Filter the data df_fuel_type <- df_tidy %>% filter(fuel==fuel_type) %>% select(datetime,megawatt) #Save out data as csv write.csv(df_fuel_type, paste(fuel_type,"_",Sys.Date(),".csv",sep="")) ``` 3. Notice the lines in our script that define an object from a command line arguments ```r theme={null} args <- commandArgs(trailingOnly = TRUE) fuel_type <- args[1] ``` 4. Save the files and Stop and Commit the workspace session. 2. Configure the Launcher. 1. Go to the Launcher page. It is under the Publish menu on the project page. 2. Click **New Launcher**. 3. Name the launcher "Power Generation Forecast Data". 4. Copy and paste the following into the field "Command to run": ```r theme={null} Power_for_Launcher.R ${fuel} ``` You should see the following parameters: 5. Select the **fuel\_type** parameter and change the type to **Select (Drop-down menu)**. 6. Copy and paste the following into the **Allowed Values** field: ```r theme={null} CCGT, OIL, COAL, NUCLEAR, WIND, PS, NPSHYD, OCGT, OTHER, INTFR, INTIRL, INTNED, INTEW, BIOMASS, INTEM ``` 7. Click **Save Launcher**. 3. Try out the Launcher. 1. Go back to the main Launcher page. 2. Click **Run** for the "Power Generation Forecast Trainer" launcher. 3. Select a fuel type from the dropdown. 4. Click **Run**. This will execute the parameterized R script with the parameters that you selected. In this particular launcher, your dataset is filtered based on your input parameter with the results returned as a csv. When the run has been completed, an email will be sent to you and others that you optionally specified in the launcher with the resulting files. See [Set Custom Execution Notifications](/cloud/platform-capabilities/core-concepts/jobs/customize-job-results) to learn how to customize the resulting email. ## Domino endpoints If you want your model to serve another application, you will want to serve it in the form of an API endpoint. [Domino endpoints](/cloud/platform-capabilities/features/model-deployment) are scalable REST APIs that can create an endpoint from any function in a Python or R script. The Domino endpoints are commonly used when you need an API to query your model in near real-time. For example, we created a model to forecast power generation of combined cycle gas turbines in the UK. In this section, we will deploy an API that uses the [previously trained model](/cloud/getting-started/for-modelers-and-builders/get-started-r/5-develop-model) to predict the generated power given a date in the future. To do so, we will create a new [compute environment](/cloud/platform-capabilities/core-concepts/compute-environments/manage-compute-environments) to install necessary packages, create a new file with the function we want to expose as an API, and finally deploy the API. 1. Create a new file with the function we want to expose as an API. 1. From the Files page of your project, click **Add File**. 2. Name your file `forecast_predictor.R`. 3. Enter the following contents: ```r theme={null} library("prophet") m <- readRDS(file = "model.rds") domino_endpoint <- function(year, month, day, hour, minute) { date <- paste(year, "-", month, "-", day, " ", hour, ":", minute, sep="") date = as.POSIXct(date, format="%Y-%m-%d %H:%M") df_api <- data.frame(ds=date) df2 <- predict(m, df_api) return(df2["yhat"]) } ``` 4. Click **Save**. 2. Deploy the API. 1. Go to the Publish/Domino endpoints page in your project. 2. Click **New endpoint**. 3. Name your model, provide a description, and click **Next**. 4. Enter the name of the file that you created in the previous step. 5. Enter the name of the function that you want to expose as an API. 6. Click **Create endpoint**. 3. Test the API. 1. Wait for the Domino endpoint status to turn to Running. This might take a few minutes. 2. Click the **Overview** tab. 3. Enter the following into the tester: ```json theme={null} { "data": { "year": 2019, "month": 10, "day": 15, "hour": 8, "minute": 15 } } ``` 4. Click **Send**. If successful, you will see the response on the right panel. As a REST API, any other common programming language will be able to call it. Code snippets from some popular languages are listed in the other tabs. Domino endpoints are built as docker images and deployed on Domino. You can export the endpoint images to your external container registry and deploy them in any other hosting environment outside of Domino using your custom CI/CD pipeline. The [Domino Platform API](/cloud/reference/api/domino-open-api) enables you to programmatically build new endpoint images on Domino and export them to your external container registry. ## Web applications When experiments in Domino yield interesting results that you want to share with your colleagues, you can easily do so with a [Domino App](/cloud/platform-capabilities/core-concepts/products/apps). Domino supports hosting Apps built with many popular frameworks, including Flask, Shiny, and Dash. While Apps can be significantly more sophisticated and provide far more functionality than a Launcher, they also require significantly more code and knowledge in at least one framework. In this section, we will convert some code that we developed when we [developed the model](/cloud/getting-started/for-modelers-and-builders/get-started-r/5-develop-model) and create a [Shiny](https://shiny.rstudio.com/) app. 1. Add the `app.R` file, which will describe the app in Shiny, to the project: ```r theme={null} library(tidyverse) library(lubridate) library(prophet) library(dygraphs) col_names <- c('HDF', 'date', 'half_hour_increment', 'CCGT', 'OIL', 'COAL', 'NUCLEAR', 'WIND', 'PS', 'NPSHYD', 'OCGT', 'OTHER', 'INTFR', 'INTIRL', 'INTNED', 'INTEW', 'BIOMASS', 'INTEM') df <- read.csv('data.csv',header = FALSE,col.names = col_names,stringsAsFactors = FALSE) #remove the first and last row df <- df[-1,] df <- df[-nrow(df),] fuels <- c('CCGT', 'OIL', 'COAL', 'NUCLEAR', 'WIND', 'PS', 'NPSHYD', 'OCGT', 'OTHER', 'INTFR', 'INTIRL', 'INTNED', 'INTEW', 'BIOMASS', 'INTEM') predict_ln <- round((nrow(df))*.2) #Tidy the data and split by fuel df_tidy <- df %>% mutate(ds=as.POSIXct(as.Date(date, "%Y%m%d"))+minutes(30*(half_hour_increment-1))) %>% select(-c('HDF', 'date', 'half_hour_increment')) %>% gather("fuel", "y", -ds) %>% split(.$fuel) #remove unused column df_tidy <- lapply(df_tidy, function(x) { x["fuel"] <- NULL; x }) #Train the model m_list <- map(df_tidy, prophet) #Create dataframes of future dates future_list <- map(m_list, make_future_dataframe, periods = predict_ln,freq = 1800 ) #Pre-Calc yhat for future dates #forecast_list <- map2(m_list, future_list, predict) # map2 because we have two inputs ui <- fluidPage( verticalLayout( h2(textOutput("text1")), selectInput(inputId = "fuel_type", label = "Fuel Type", choices = fuels, selected = "CCGT"), dygraphOutput("plot1"))) server <- function(input, output) { output$plot1 <- renderDygraph({ forecast <- predict(m_list[[input$fuel_type]], future_list[[input$fuel_type]]) dyplot.prophet(m_list[[input$fuel_type]], forecast) }) output$text1 <- renderText({ input$fuel_type }) } shinyApp(ui = ui, server = server) ``` 2. Add an `app.sh` file to the project, which provides the commands to instantiate the app: ```r theme={null} R -e 'shiny::runApp("app.R", port=8888, host="0.0.0.0")' ``` 3. Publish the App. 1. Go to the App page under the Publish menu of your project. 2. Enter a title and a description for your app. 3. Click **Publish**. 4. After your app starts successfully, which might take a few minutes, you can click **View App** to open it. 4. Share your app with your colleagues. 1. Back on the Publish/App page, click the **App Permissions** tab. 2. Invite your colleagues by username or email. 3. Or, toggle the Access Permissions level to make it publicly available. Share your app See [Domino Apps](/cloud/platform-capabilities/core-concepts/products/apps) for more information.