Docs Home Pulumi IaC Pulumi ESC Pulumi Insights Pulumi Cloud Packages Tutorials
  1. Packages
  2. Incapsula Provider
  3. API Docs
  4. SiteCacheConfiguration
incapsula 3.33.0 published on Wednesday, Apr 30, 2025 by imperva
imperva/terraform-provider-incapsula

incapsula.SiteCacheConfiguration

Explore with Pulumi AI

incapsula logo
incapsula 3.33.0 published on Wednesday, Apr 30, 2025 by imperva
imperva/terraform-provider-incapsula

    Configure content caching for your website.

    Note: This resource is designed to work with sites represented by the “incapsula.SiteV3” resource, and cannot be used together in the same configuration with the “incapsula.Site” resource.

    Example Usage

    Basic Usage - Site Cache Configuration

    import * as pulumi from "@pulumi/pulumi";
import * as incapsula from "@pulumi/incapsula";

const exampleSiteCacheConfiguration = new incapsula.SiteCacheConfiguration("exampleSiteCacheConfiguration", {
    siteId: incapsula_site_v3["example-site-v3"].id,
    clientComplyNoCache: true,
    clientEnableClientSideCaching: true,
    clientSendAgeHeader: true,
    keyComplyVary: true,
    keyUniteNakedFullCache: true,
    modeHttps: "include_all_resources",
    modeLevel: "standard",
    modeTime: 1000,
    responseCache300x: true,
    responseCache404Enabled: true,
    responseCache404Time: 60,
    responseCacheEmptyResponses: true,
    responseCacheHttp10Responses: true,
    responseCacheResponseHeaderMode: "custom",
    responseCacheResponseHeaders: [
        "Access-Control-Allow-Origin",
        "Foo-Bar-Header",
    ],
    responseCacheShield: true,
    responseStaleContentMode: "custom",
    responseStaleContentTime: 1000,
    responseTagResponseHeader: "Example-Tag-Value-Header",
    ttlPreferLastModified: true,
    ttlUseShortestCaching: true,
});

    import pulumi
import pulumi_incapsula as incapsula

example_site_cache_configuration = incapsula.SiteCacheConfiguration("exampleSiteCacheConfiguration",
    site_id=incapsula_site_v3["example-site-v3"]["id"],
    client_comply_no_cache=True,
    client_enable_client_side_caching=True,
    client_send_age_header=True,
    key_comply_vary=True,
    key_unite_naked_full_cache=True,
    mode_https="include_all_resources",
    mode_level="standard",
    mode_time=1000,
    response_cache300x=True,
    response_cache404_enabled=True,
    response_cache404_time=60,
    response_cache_empty_responses=True,
    response_cache_http10_responses=True,
    response_cache_response_header_mode="custom",
    response_cache_response_headers=[
        "Access-Control-Allow-Origin",
        "Foo-Bar-Header",
    ],
    response_cache_shield=True,
    response_stale_content_mode="custom",
    response_stale_content_time=1000,
    response_tag_response_header="Example-Tag-Value-Header",
    ttl_prefer_last_modified=True,
    ttl_use_shortest_caching=True)

    package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/incapsula/v3/incapsula"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := incapsula.NewSiteCacheConfiguration(ctx, "exampleSiteCacheConfiguration", &incapsula.SiteCacheConfigurationArgs{
			SiteId:                          pulumi.Any(incapsula_site_v3.ExampleSiteV3.Id),
			ClientComplyNoCache:             pulumi.Bool(true),
			ClientEnableClientSideCaching:   pulumi.Bool(true),
			ClientSendAgeHeader:             pulumi.Bool(true),
			KeyComplyVary:                   pulumi.Bool(true),
			KeyUniteNakedFullCache:          pulumi.Bool(true),
			ModeHttps:                       pulumi.String("include_all_resources"),
			ModeLevel:                       pulumi.String("standard"),
			ModeTime:                        pulumi.Float64(1000),
			ResponseCache300x:               pulumi.Bool(true),
			ResponseCache404Enabled:         pulumi.Bool(true),
			ResponseCache404Time:            pulumi.Float64(60),
			ResponseCacheEmptyResponses:     pulumi.Bool(true),
			ResponseCacheHttp10Responses:    pulumi.Bool(true),
			ResponseCacheResponseHeaderMode: pulumi.String("custom"),
			ResponseCacheResponseHeaders: pulumi.StringArray{
				pulumi.String("Access-Control-Allow-Origin"),
				pulumi.String("Foo-Bar-Header"),
			},
			ResponseCacheShield:       pulumi.Bool(true),
			ResponseStaleContentMode:  pulumi.String("custom"),
			ResponseStaleContentTime:  pulumi.Float64(1000),
			ResponseTagResponseHeader: pulumi.String("Example-Tag-Value-Header"),
			TtlPreferLastModified:     pulumi.Bool(true),
			TtlUseShortestCaching:     pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Incapsula = Pulumi.Incapsula;

return await Deployment.RunAsync(() => 
{
    var exampleSiteCacheConfiguration = new Incapsula.SiteCacheConfiguration("exampleSiteCacheConfiguration", new()
    {
        SiteId = incapsula_site_v3.Example_site_v3.Id,
        ClientComplyNoCache = true,
        ClientEnableClientSideCaching = true,
        ClientSendAgeHeader = true,
        KeyComplyVary = true,
        KeyUniteNakedFullCache = true,
        ModeHttps = "include_all_resources",
        ModeLevel = "standard",
        ModeTime = 1000,
        ResponseCache300x = true,
        ResponseCache404Enabled = true,
        ResponseCache404Time = 60,
        ResponseCacheEmptyResponses = true,
        ResponseCacheHttp10Responses = true,
        ResponseCacheResponseHeaderMode = "custom",
        ResponseCacheResponseHeaders = new[]
        {
            "Access-Control-Allow-Origin",
            "Foo-Bar-Header",
        },
        ResponseCacheShield = true,
        ResponseStaleContentMode = "custom",
        ResponseStaleContentTime = 1000,
        ResponseTagResponseHeader = "Example-Tag-Value-Header",
        TtlPreferLastModified = true,
        TtlUseShortestCaching = true,
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.incapsula.SiteCacheConfiguration;
import com.pulumi.incapsula.SiteCacheConfigurationArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var exampleSiteCacheConfiguration = new SiteCacheConfiguration("exampleSiteCacheConfiguration", SiteCacheConfigurationArgs.builder()
            .siteId(incapsula_site_v3.example-site-v3().id())
            .clientComplyNoCache(true)
            .clientEnableClientSideCaching(true)
            .clientSendAgeHeader(true)
            .keyComplyVary(true)
            .keyUniteNakedFullCache(true)
            .modeHttps("include_all_resources")
            .modeLevel("standard")
            .modeTime(1000)
            .responseCache300x(true)
            .responseCache404Enabled(true)
            .responseCache404Time(60)
            .responseCacheEmptyResponses(true)
            .responseCacheHttp10Responses(true)
            .responseCacheResponseHeaderMode("custom")
            .responseCacheResponseHeaders(            
                "Access-Control-Allow-Origin",
                "Foo-Bar-Header")
            .responseCacheShield(true)
            .responseStaleContentMode("custom")
            .responseStaleContentTime(1000)
            .responseTagResponseHeader("Example-Tag-Value-Header")
            .ttlPreferLastModified(true)
            .ttlUseShortestCaching(true)
            .build());

    }
}

    resources:
  exampleSiteCacheConfiguration:
    type: incapsula:SiteCacheConfiguration
    properties:
      siteId: ${incapsula_site_v3"example-site-v3"[%!s(MISSING)].id}
      clientComplyNoCache: true
      clientEnableClientSideCaching: true
      clientSendAgeHeader: true
      keyComplyVary: true
      keyUniteNakedFullCache: true
      modeHttps: include_all_resources
      modeLevel: standard
      modeTime: 1000
      responseCache300x: true
      responseCache404Enabled: true
      responseCache404Time: 60
      responseCacheEmptyResponses: true
      responseCacheHttp10Responses: true
      responseCacheResponseHeaderMode: custom
      responseCacheResponseHeaders:
        - Access-Control-Allow-Origin
        - Foo-Bar-Header
      responseCacheShield: true
      responseStaleContentMode: custom
      responseStaleContentTime: 1000
      responseTagResponseHeader: Example-Tag-Value-Header
      ttlPreferLastModified: true
      ttlUseShortestCaching: true

    Create SiteCacheConfiguration Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new SiteCacheConfiguration(name: string, args: SiteCacheConfigurationArgs, opts?: CustomResourceOptions);
    @overload
def SiteCacheConfiguration(resource_name: str,
                           args: SiteCacheConfigurationArgs,
                           opts: Optional[ResourceOptions] = None)

@overload
def SiteCacheConfiguration(resource_name: str,
                           opts: Optional[ResourceOptions] = None,
                           site_id: Optional[float] = None,
                           response_cache404_time: Optional[float] = None,
                           response_cache_http10_responses: Optional[bool] = None,
                           key_comply_vary: Optional[bool] = None,
                           key_unite_naked_full_cache: Optional[bool] = None,
                           mode_https: Optional[str] = None,
                           mode_level: Optional[str] = None,
                           mode_time: Optional[float] = None,
                           response_cache300x: Optional[bool] = None,
                           response_cache404_enabled: Optional[bool] = None,
                           response_cache_response_header_mode: Optional[str] = None,
                           client_send_age_header: Optional[bool] = None,
                           response_cache_empty_responses: Optional[bool] = None,
                           client_comply_no_cache: Optional[bool] = None,
                           response_cache_response_headers: Optional[Sequence[str]] = None,
                           response_cache_shield: Optional[bool] = None,
                           response_stale_content_mode: Optional[str] = None,
                           response_stale_content_time: Optional[float] = None,
                           response_tag_response_header: Optional[str] = None,
                           site_cache_configuration_id: Optional[str] = None,
                           client_enable_client_side_caching: Optional[bool] = None,
                           ttl_prefer_last_modified: Optional[bool] = None,
                           ttl_use_shortest_caching: Optional[bool] = None)
    func NewSiteCacheConfiguration(ctx *Context, name string, args SiteCacheConfigurationArgs, opts ...ResourceOption) (*SiteCacheConfiguration, error)
    public SiteCacheConfiguration(string name, SiteCacheConfigurationArgs args, CustomResourceOptions? opts = null)
    public SiteCacheConfiguration(String name, SiteCacheConfigurationArgs args)
public SiteCacheConfiguration(String name, SiteCacheConfigurationArgs args, CustomResourceOptions options)

    type: incapsula:SiteCacheConfiguration
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args SiteCacheConfigurationArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args SiteCacheConfigurationArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args SiteCacheConfigurationArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args SiteCacheConfigurationArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args SiteCacheConfigurationArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var siteCacheConfigurationResource = new Incapsula.SiteCacheConfiguration("siteCacheConfigurationResource", new()
{
    SiteId = 0,
    ResponseCache404Time = 0,
    ResponseCacheHttp10Responses = false,
    KeyComplyVary = false,
    KeyUniteNakedFullCache = false,
    ModeHttps = "string",
    ModeLevel = "string",
    ModeTime = 0,
    ResponseCache300x = false,
    ResponseCache404Enabled = false,
    ResponseCacheResponseHeaderMode = "string",
    ClientSendAgeHeader = false,
    ResponseCacheEmptyResponses = false,
    ClientComplyNoCache = false,
    ResponseCacheResponseHeaders = new[]
    {
        "string",
    },
    ResponseCacheShield = false,
    ResponseStaleContentMode = "string",
    ResponseStaleContentTime = 0,
    ResponseTagResponseHeader = "string",
    SiteCacheConfigurationId = "string",
    ClientEnableClientSideCaching = false,
    TtlPreferLastModified = false,
    TtlUseShortestCaching = false,
});

    example, err := incapsula.NewSiteCacheConfiguration(ctx, "siteCacheConfigurationResource", &incapsula.SiteCacheConfigurationArgs{
	SiteId:                          pulumi.Float64(0),
	ResponseCache404Time:            pulumi.Float64(0),
	ResponseCacheHttp10Responses:    pulumi.Bool(false),
	KeyComplyVary:                   pulumi.Bool(false),
	KeyUniteNakedFullCache:          pulumi.Bool(false),
	ModeHttps:                       pulumi.String("string"),
	ModeLevel:                       pulumi.String("string"),
	ModeTime:                        pulumi.Float64(0),
	ResponseCache300x:               pulumi.Bool(false),
	ResponseCache404Enabled:         pulumi.Bool(false),
	ResponseCacheResponseHeaderMode: pulumi.String("string"),
	ClientSendAgeHeader:             pulumi.Bool(false),
	ResponseCacheEmptyResponses:     pulumi.Bool(false),
	ClientComplyNoCache:             pulumi.Bool(false),
	ResponseCacheResponseHeaders: pulumi.StringArray{
		pulumi.String("string"),
	},
	ResponseCacheShield:           pulumi.Bool(false),
	ResponseStaleContentMode:      pulumi.String("string"),
	ResponseStaleContentTime:      pulumi.Float64(0),
	ResponseTagResponseHeader:     pulumi.String("string"),
	SiteCacheConfigurationId:      pulumi.String("string"),
	ClientEnableClientSideCaching: pulumi.Bool(false),
	TtlPreferLastModified:         pulumi.Bool(false),
	TtlUseShortestCaching:         pulumi.Bool(false),
})

    var siteCacheConfigurationResource = new SiteCacheConfiguration("siteCacheConfigurationResource", SiteCacheConfigurationArgs.builder()
    .siteId(0)
    .responseCache404Time(0)
    .responseCacheHttp10Responses(false)
    .keyComplyVary(false)
    .keyUniteNakedFullCache(false)
    .modeHttps("string")
    .modeLevel("string")
    .modeTime(0)
    .responseCache300x(false)
    .responseCache404Enabled(false)
    .responseCacheResponseHeaderMode("string")
    .clientSendAgeHeader(false)
    .responseCacheEmptyResponses(false)
    .clientComplyNoCache(false)
    .responseCacheResponseHeaders("string")
    .responseCacheShield(false)
    .responseStaleContentMode("string")
    .responseStaleContentTime(0)
    .responseTagResponseHeader("string")
    .siteCacheConfigurationId("string")
    .clientEnableClientSideCaching(false)
    .ttlPreferLastModified(false)
    .ttlUseShortestCaching(false)
    .build());

    site_cache_configuration_resource = incapsula.SiteCacheConfiguration("siteCacheConfigurationResource",
    site_id=0,
    response_cache404_time=0,
    response_cache_http10_responses=False,
    key_comply_vary=False,
    key_unite_naked_full_cache=False,
    mode_https="string",
    mode_level="string",
    mode_time=0,
    response_cache300x=False,
    response_cache404_enabled=False,
    response_cache_response_header_mode="string",
    client_send_age_header=False,
    response_cache_empty_responses=False,
    client_comply_no_cache=False,
    response_cache_response_headers=["string"],
    response_cache_shield=False,
    response_stale_content_mode="string",
    response_stale_content_time=0,
    response_tag_response_header="string",
    site_cache_configuration_id="string",
    client_enable_client_side_caching=False,
    ttl_prefer_last_modified=False,
    ttl_use_shortest_caching=False)

    const siteCacheConfigurationResource = new incapsula.SiteCacheConfiguration("siteCacheConfigurationResource", {
    siteId: 0,
    responseCache404Time: 0,
    responseCacheHttp10Responses: false,
    keyComplyVary: false,
    keyUniteNakedFullCache: false,
    modeHttps: "string",
    modeLevel: "string",
    modeTime: 0,
    responseCache300x: false,
    responseCache404Enabled: false,
    responseCacheResponseHeaderMode: "string",
    clientSendAgeHeader: false,
    responseCacheEmptyResponses: false,
    clientComplyNoCache: false,
    responseCacheResponseHeaders: ["string"],
    responseCacheShield: false,
    responseStaleContentMode: "string",
    responseStaleContentTime: 0,
    responseTagResponseHeader: "string",
    siteCacheConfigurationId: "string",
    clientEnableClientSideCaching: false,
    ttlPreferLastModified: false,
    ttlUseShortestCaching: false,
});

    type: incapsula:SiteCacheConfiguration
properties:
    clientComplyNoCache: false
    clientEnableClientSideCaching: false
    clientSendAgeHeader: false
    keyComplyVary: false
    keyUniteNakedFullCache: false
    modeHttps: string
    modeLevel: string
    modeTime: 0
    responseCache300x: false
    responseCache404Enabled: false
    responseCache404Time: 0
    responseCacheEmptyResponses: false
    responseCacheHttp10Responses: false
    responseCacheResponseHeaderMode: string
    responseCacheResponseHeaders:
        - string
    responseCacheShield: false
    responseStaleContentMode: string
    responseStaleContentTime: 0
    responseTagResponseHeader: string
    siteCacheConfigurationId: string
    siteId: 0
    ttlPreferLastModified: false
    ttlUseShortestCaching: false

    SiteCacheConfiguration Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The SiteCacheConfiguration resource accepts the following input properties:

    SiteId double
    Numeric identifier of the site to operate on.
    ClientComplyNoCache bool
    Comply with No-Cache and Max-Age directives in client requests. By default, these cache directives are ignored. Resources are dynamically profiled and re-configured to optimize performance. Default: false
    ClientEnableClientSideCaching bool
    Cache content on client browsers or applications. When not enabled, content is cached only on the Imperva proxies. Default: false
    ClientSendAgeHeader bool
    Send Cache-Control: max-age and Age headers. Default: false
    KeyComplyVary bool
    Comply with Vary. Cache resources in accordance with the Vary response header. Default: false
    KeyUniteNakedFullCache bool
    Use the Same Cache for Full and Naked Domains. For example, use the same cached resource for www.example.com/a and example.com/a. Default: false
    ModeHttps string
    The resources that are cached over HTTPS, the general level applies. Default: disabled Possible values:

    • disabled - No resources are cached over HTTPS.
    • dont_include_html - Only images, css files, js files, and resources defined with the 'Cache-Control: public' header may be cached over HTTPS.
    • include_html - Same as dont_include_html, also HTML files may be cached over HTTPS.
    • include_all_resources - All resources may be cached over HTTPS.
    ModeLevel string
    Caching level. Default: smart Possible values:

    • disabled - Turn off site caching entirely, including user-defined custom cache rules. Note: Since all other attributes require caching, it is recommended to clear all resource attributes from configuration when disabling the cache.
    • custom_cache_rules_only - Disable caching, unless specified otherwise by a custom cache rule.
    • standard - Cache according to standard HTTP headers.
    • smart - Cache according to standard HTTP headers as well as profile dynamic pages to identify and cache static content that was not marked as static. In addition to content that was marked by the site's developer / web server as static using standard HTTP headers, Imperva also profiles other resources to identify and cache static content that was not marked as such.
    • all_resources - Cache every resource on the web server for the specified amount of time. All site content is cached.
    ModeTime double
    The time, in seconds, that you set for this option determines how often the cache is refreshed. Relevant for the include_html and include_all_resources levels only.
    ResponseCache300x bool
    When this option is checked Imperva will cache 301, 302, 303, 307, and 308 redirect response headers containing the target URI. Default: false
    ResponseCache404Enabled bool
    Whether or not to cache 404 responses. Default: false
    ResponseCache404Time double
    The time in seconds to cache 404 responses. Value should be divisible by 60.
    ResponseCacheEmptyResponses bool
    Cache responses that don’t have a message body. Default: false
    ResponseCacheHttp10Responses bool
    Cache HTTP 1.0 type responses that don’t include the Content-Length header or chunking. Default: false
    ResponseCacheResponseHeaderMode string
    The working mode for caching response headers. Default: disabled Possible values:

    • disabled
    • all - Cache all headers in responses.
    • custom - Specify which response headers should be cached along with the resource.
    ResponseCacheResponseHeaders List<string>
    An array of strings representing the response headers to be cached when working in custom mode. If empty, no response headers are cached. For example: ["Access-Control-Allow-Origin","Access-Control-Allow-Methods"].
    ResponseCacheShield bool
    Adds an intermediate cache between other Imperva PoPs and your origin servers to protect your servers from redundant requests. Default: false
    ResponseStaleContentMode string
    The working mode for serving stale content. Default: disabled Possible values:

    • disabled - Disable serving of stale content.
    • adaptive - Stale content is served for a duration of 2 to 24 hours based on the time passed since the resource was last updated.
    • custom - Serve stale content for the specified amount of time.
    ResponseStaleContentTime double
    The time, in seconds, to serve stale content for when working in custom work mode.
    ResponseTagResponseHeader string
    Tag the response according to the value of this header. Specify which origin response header contains the cache tags in your resources.
    SiteCacheConfigurationId string
    Unique identifier in the API for the Site Cache configuration. The id is identical to Site id.
    TtlPreferLastModified bool
    Prefer 'Last Modified' over eTag. When this option is checked, Imperva prefers using Last Modified values (if available) over eTag values (recommended on multi-server setups). Default: false
    TtlUseShortestCaching bool
    Use shortest caching duration in case of conflicts. By default, the longest duration is used in case of conflict between caching rules or modes. When this option is checked, Imperva uses the shortest duration in case of conflict. Default: false
    SiteId float64
    Numeric identifier of the site to operate on.
    ClientComplyNoCache bool
    Comply with No-Cache and Max-Age directives in client requests. By default, these cache directives are ignored. Resources are dynamically profiled and re-configured to optimize performance. Default: false
    ClientEnableClientSideCaching bool
    Cache content on client browsers or applications. When not enabled, content is cached only on the Imperva proxies. Default: false
    ClientSendAgeHeader bool
    Send Cache-Control: max-age and Age headers. Default: false
    KeyComplyVary bool
    Comply with Vary. Cache resources in accordance with the Vary response header. Default: false
    KeyUniteNakedFullCache bool
    Use the Same Cache for Full and Naked Domains. For example, use the same cached resource for www.example.com/a and example.com/a. Default: false
    ModeHttps string
    The resources that are cached over HTTPS, the general level applies. Default: disabled Possible values:

    • disabled - No resources are cached over HTTPS.
    • dont_include_html - Only images, css files, js files, and resources defined with the 'Cache-Control: public' header may be cached over HTTPS.
    • include_html - Same as dont_include_html, also HTML files may be cached over HTTPS.
    • include_all_resources - All resources may be cached over HTTPS.
    ModeLevel string
    Caching level. Default: smart Possible values:

    • disabled - Turn off site caching entirely, including user-defined custom cache rules. Note: Since all other attributes require caching, it is recommended to clear all resource attributes from configuration when disabling the cache.
    • custom_cache_rules_only - Disable caching, unless specified otherwise by a custom cache rule.
    • standard - Cache according to standard HTTP headers.
    • smart - Cache according to standard HTTP headers as well as profile dynamic pages to identify and cache static content that was not marked as static. In addition to content that was marked by the site's developer / web server as static using standard HTTP headers, Imperva also profiles other resources to identify and cache static content that was not marked as such.
    • all_resources - Cache every resource on the web server for the specified amount of time. All site content is cached.
    ModeTime float64
    The time, in seconds, that you set for this option determines how often the cache is refreshed. Relevant for the include_html and include_all_resources levels only.
    ResponseCache300x bool
    When this option is checked Imperva will cache 301, 302, 303, 307, and 308 redirect response headers containing the target URI. Default: false
    ResponseCache404Enabled bool
    Whether or not to cache 404 responses. Default: false
    ResponseCache404Time float64
    The time in seconds to cache 404 responses. Value should be divisible by 60.
    ResponseCacheEmptyResponses bool
    Cache responses that don’t have a message body. Default: false
    ResponseCacheHttp10Responses bool
    Cache HTTP 1.0 type responses that don’t include the Content-Length header or chunking. Default: false
    ResponseCacheResponseHeaderMode string
    The working mode for caching response headers. Default: disabled Possible values:

    • disabled
    • all - Cache all headers in responses.
    • custom - Specify which response headers should be cached along with the resource.
    ResponseCacheResponseHeaders []string
    An array of strings representing the response headers to be cached when working in custom mode. If empty, no response headers are cached. For example: ["Access-Control-Allow-Origin","Access-Control-Allow-Methods"].
    ResponseCacheShield bool
    Adds an intermediate cache between other Imperva PoPs and your origin servers to protect your servers from redundant requests. Default: false
    ResponseStaleContentMode string
    The working mode for serving stale content. Default: disabled Possible values:

    • disabled - Disable serving of stale content.
    • adaptive - Stale content is served for a duration of 2 to 24 hours based on the time passed since the resource was last updated.
    • custom - Serve stale content for the specified amount of time.
    ResponseStaleContentTime float64
    The time, in seconds, to serve stale content for when working in custom work mode.
    ResponseTagResponseHeader string
    Tag the response according to the value of this header. Specify which origin response header contains the cache tags in your resources.
    SiteCacheConfigurationId string
    Unique identifier in the API for the Site Cache configuration. The id is identical to Site id.
    TtlPreferLastModified bool
    Prefer 'Last Modified' over eTag. When this option is checked, Imperva prefers using Last Modified values (if available) over eTag values (recommended on multi-server setups). Default: false
    TtlUseShortestCaching bool
    Use shortest caching duration in case of conflicts. By default, the longest duration is used in case of conflict between caching rules or modes. When this option is checked, Imperva uses the shortest duration in case of conflict. Default: false
    siteId Double
    Numeric identifier of the site to operate on.
    clientComplyNoCache Boolean
    Comply with No-Cache and Max-Age directives in client requests. By default, these cache directives are ignored. Resources are dynamically profiled and re-configured to optimize performance. Default: false
    clientEnableClientSideCaching Boolean
    Cache content on client browsers or applications. When not enabled, content is cached only on the Imperva proxies. Default: false
    clientSendAgeHeader Boolean
    Send Cache-Control: max-age and Age headers. Default: false
    keyComplyVary Boolean
    Comply with Vary. Cache resources in accordance with the Vary response header. Default: false
    keyUniteNakedFullCache Boolean
    Use the Same Cache for Full and Naked Domains. For example, use the same cached resource for www.example.com/a and example.com/a. Default: false
    modeHttps String
    The resources that are cached over HTTPS, the general level applies. Default: disabled Possible values:

    • disabled - No resources are cached over HTTPS.
    • dont_include_html - Only images, css files, js files, and resources defined with the 'Cache-Control: public' header may be cached over HTTPS.
    • include_html - Same as dont_include_html, also HTML files may be cached over HTTPS.
    • include_all_resources - All resources may be cached over HTTPS.
    modeLevel String
    Caching level. Default: smart Possible values:

    • disabled - Turn off site caching entirely, including user-defined custom cache rules. Note: Since all other attributes require caching, it is recommended to clear all resource attributes from configuration when disabling the cache.
    • custom_cache_rules_only - Disable caching, unless specified otherwise by a custom cache rule.
    • standard - Cache according to standard HTTP headers.
    • smart - Cache according to standard HTTP headers as well as profile dynamic pages to identify and cache static content that was not marked as static. In addition to content that was marked by the site's developer / web server as static using standard HTTP headers, Imperva also profiles other resources to identify and cache static content that was not marked as such.
    • all_resources - Cache every resource on the web server for the specified amount of time. All site content is cached.
    modeTime Double
    The time, in seconds, that you set for this option determines how often the cache is refreshed. Relevant for the include_html and include_all_resources levels only.
    responseCache300x Boolean
    When this option is checked Imperva will cache 301, 302, 303, 307, and 308 redirect response headers containing the target URI. Default: false
    responseCache404Enabled Boolean
    Whether or not to cache 404 responses. Default: false
    responseCache404Time Double
    The time in seconds to cache 404 responses. Value should be divisible by 60.
    responseCacheEmptyResponses Boolean
    Cache responses that don’t have a message body. Default: false
    responseCacheHttp10Responses Boolean
    Cache HTTP 1.0 type responses that don’t include the Content-Length header or chunking. Default: false
    responseCacheResponseHeaderMode String
    The working mode for caching response headers. Default: disabled Possible values:

    • disabled
    • all - Cache all headers in responses.
    • custom - Specify which response headers should be cached along with the resource.
    responseCacheResponseHeaders List<String>
    An array of strings representing the response headers to be cached when working in custom mode. If empty, no response headers are cached. For example: ["Access-Control-Allow-Origin","Access-Control-Allow-Methods"].
    responseCacheShield Boolean
    Adds an intermediate cache between other Imperva PoPs and your origin servers to protect your servers from redundant requests. Default: false
    responseStaleContentMode String
    The working mode for serving stale content. Default: disabled Possible values:

    • disabled - Disable serving of stale content.
    • adaptive - Stale content is served for a duration of 2 to 24 hours based on the time passed since the resource was last updated.
    • custom - Serve stale content for the specified amount of time.
    responseStaleContentTime Double
    The time, in seconds, to serve stale content for when working in custom work mode.
    responseTagResponseHeader String
    Tag the response according to the value of this header. Specify which origin response header contains the cache tags in your resources.
    siteCacheConfigurationId String
    Unique identifier in the API for the Site Cache configuration. The id is identical to Site id.
    ttlPreferLastModified Boolean
    Prefer 'Last Modified' over eTag. When this option is checked, Imperva prefers using Last Modified values (if available) over eTag values (recommended on multi-server setups). Default: false
    ttlUseShortestCaching Boolean
    Use shortest caching duration in case of conflicts. By default, the longest duration is used in case of conflict between caching rules or modes. When this option is checked, Imperva uses the shortest duration in case of conflict. Default: false
    siteId number
    Numeric identifier of the site to operate on.
    clientComplyNoCache boolean
    Comply with No-Cache and Max-Age directives in client requests. By default, these cache directives are ignored. Resources are dynamically profiled and re-configured to optimize performance. Default: false
    clientEnableClientSideCaching boolean
    Cache content on client browsers or applications. When not enabled, content is cached only on the Imperva proxies. Default: false
    clientSendAgeHeader boolean
    Send Cache-Control: max-age and Age headers. Default: false
    keyComplyVary boolean
    Comply with Vary. Cache resources in accordance with the Vary response header. Default: false
    keyUniteNakedFullCache boolean
    Use the Same Cache for Full and Naked Domains. For example, use the same cached resource for www.example.com/a and example.com/a. Default: false
    modeHttps string
    The resources that are cached over HTTPS, the general level applies. Default: disabled Possible values:

    • disabled - No resources are cached over HTTPS.
    • dont_include_html - Only images, css files, js files, and resources defined with the 'Cache-Control: public' header may be cached over HTTPS.
    • include_html - Same as dont_include_html, also HTML files may be cached over HTTPS.
    • include_all_resources - All resources may be cached over HTTPS.
    modeLevel string
    Caching level. Default: smart Possible values:

    • disabled - Turn off site caching entirely, including user-defined custom cache rules. Note: Since all other attributes require caching, it is recommended to clear all resource attributes from configuration when disabling the cache.
    • custom_cache_rules_only - Disable caching, unless specified otherwise by a custom cache rule.
    • standard - Cache according to standard HTTP headers.
    • smart - Cache according to standard HTTP headers as well as profile dynamic pages to identify and cache static content that was not marked as static. In addition to content that was marked by the site's developer / web server as static using standard HTTP headers, Imperva also profiles other resources to identify and cache static content that was not marked as such.
    • all_resources - Cache every resource on the web server for the specified amount of time. All site content is cached.
    modeTime number
    The time, in seconds, that you set for this option determines how often the cache is refreshed. Relevant for the include_html and include_all_resources levels only.
    responseCache300x boolean
    When this option is checked Imperva will cache 301, 302, 303, 307, and 308 redirect response headers containing the target URI. Default: false
    responseCache404Enabled boolean
    Whether or not to cache 404 responses. Default: false
    responseCache404Time number
    The time in seconds to cache 404 responses. Value should be divisible by 60.
    responseCacheEmptyResponses boolean
    Cache responses that don’t have a message body. Default: false
    responseCacheHttp10Responses boolean
    Cache HTTP 1.0 type responses that don’t include the Content-Length header or chunking. Default: false
    responseCacheResponseHeaderMode string
    The working mode for caching response headers. Default: disabled Possible values:

    • disabled
    • all - Cache all headers in responses.
    • custom - Specify which response headers should be cached along with the resource.
    responseCacheResponseHeaders string[]
    An array of strings representing the response headers to be cached when working in custom mode. If empty, no response headers are cached. For example: ["Access-Control-Allow-Origin","Access-Control-Allow-Methods"].
    responseCacheShield boolean
    Adds an intermediate cache between other Imperva PoPs and your origin servers to protect your servers from redundant requests. Default: false
    responseStaleContentMode string
    The working mode for serving stale content. Default: disabled Possible values:

    • disabled - Disable serving of stale content.
    • adaptive - Stale content is served for a duration of 2 to 24 hours based on the time passed since the resource was last updated.
    • custom - Serve stale content for the specified amount of time.
    responseStaleContentTime number
    The time, in seconds, to serve stale content for when working in custom work mode.
    responseTagResponseHeader string
    Tag the response according to the value of this header. Specify which origin response header contains the cache tags in your resources.
    siteCacheConfigurationId string
    Unique identifier in the API for the Site Cache configuration. The id is identical to Site id.
    ttlPreferLastModified boolean
    Prefer 'Last Modified' over eTag. When this option is checked, Imperva prefers using Last Modified values (if available) over eTag values (recommended on multi-server setups). Default: false
    ttlUseShortestCaching boolean
    Use shortest caching duration in case of conflicts. By default, the longest duration is used in case of conflict between caching rules or modes. When this option is checked, Imperva uses the shortest duration in case of conflict. Default: false
    site_id float
    Numeric identifier of the site to operate on.
    client_comply_no_cache bool
    Comply with No-Cache and Max-Age directives in client requests. By default, these cache directives are ignored. Resources are dynamically profiled and re-configured to optimize performance. Default: false
    client_enable_client_side_caching bool
    Cache content on client browsers or applications. When not enabled, content is cached only on the Imperva proxies. Default: false
    client_send_age_header bool
    Send Cache-Control: max-age and Age headers. Default: false
    key_comply_vary bool
    Comply with Vary. Cache resources in accordance with the Vary response header. Default: false
    key_unite_naked_full_cache bool
    Use the Same Cache for Full and Naked Domains. For example, use the same cached resource for www.example.com/a and example.com/a. Default: false
    mode_https str
    The resources that are cached over HTTPS, the general level applies. Default: disabled Possible values:

    • disabled - No resources are cached over HTTPS.
    • dont_include_html - Only images, css files, js files, and resources defined with the 'Cache-Control: public' header may be cached over HTTPS.
    • include_html - Same as dont_include_html, also HTML files may be cached over HTTPS.
    • include_all_resources - All resources may be cached over HTTPS.
    mode_level str
    Caching level. Default: smart Possible values:

    • disabled - Turn off site caching entirely, including user-defined custom cache rules. Note: Since all other attributes require caching, it is recommended to clear all resource attributes from configuration when disabling the cache.
    • custom_cache_rules_only - Disable caching, unless specified otherwise by a custom cache rule.
    • standard - Cache according to standard HTTP headers.
    • smart - Cache according to standard HTTP headers as well as profile dynamic pages to identify and cache static content that was not marked as static. In addition to content that was marked by the site's developer / web server as static using standard HTTP headers, Imperva also profiles other resources to identify and cache static content that was not marked as such.
    • all_resources - Cache every resource on the web server for the specified amount of time. All site content is cached.
    mode_time float
    The time, in seconds, that you set for this option determines how often the cache is refreshed. Relevant for the include_html and include_all_resources levels only.
    response_cache300x bool
    When this option is checked Imperva will cache 301, 302, 303, 307, and 308 redirect response headers containing the target URI. Default: false
    response_cache404_enabled bool
    Whether or not to cache 404 responses. Default: false
    response_cache404_time float
    The time in seconds to cache 404 responses. Value should be divisible by 60.
    response_cache_empty_responses bool
    Cache responses that don’t have a message body. Default: false
    response_cache_http10_responses bool
    Cache HTTP 1.0 type responses that don’t include the Content-Length header or chunking. Default: false
    response_cache_response_header_mode str
    The working mode for caching response headers. Default: disabled Possible values:

    • disabled
    • all - Cache all headers in responses.
    • custom - Specify which response headers should be cached along with the resource.
    response_cache_response_headers Sequence[str]
    An array of strings representing the response headers to be cached when working in custom mode. If empty, no response headers are cached. For example: ["Access-Control-Allow-Origin","Access-Control-Allow-Methods"].
    response_cache_shield bool
    Adds an intermediate cache between other Imperva PoPs and your origin servers to protect your servers from redundant requests. Default: false
    response_stale_content_mode str
    The working mode for serving stale content. Default: disabled Possible values:

    • disabled - Disable serving of stale content.
    • adaptive - Stale content is served for a duration of 2 to 24 hours based on the time passed since the resource was last updated.
    • custom - Serve stale content for the specified amount of time.
    response_stale_content_time float
    The time, in seconds, to serve stale content for when working in custom work mode.
    response_tag_response_header str
    Tag the response according to the value of this header. Specify which origin response header contains the cache tags in your resources.
    site_cache_configuration_id str
    Unique identifier in the API for the Site Cache configuration. The id is identical to Site id.
    ttl_prefer_last_modified bool
    Prefer 'Last Modified' over eTag. When this option is checked, Imperva prefers using Last Modified values (if available) over eTag values (recommended on multi-server setups). Default: false
    ttl_use_shortest_caching bool
    Use shortest caching duration in case of conflicts. By default, the longest duration is used in case of conflict between caching rules or modes. When this option is checked, Imperva uses the shortest duration in case of conflict. Default: false
    siteId Number
    Numeric identifier of the site to operate on.
    clientComplyNoCache Boolean
    Comply with No-Cache and Max-Age directives in client requests. By default, these cache directives are ignored. Resources are dynamically profiled and re-configured to optimize performance. Default: false
    clientEnableClientSideCaching Boolean
    Cache content on client browsers or applications. When not enabled, content is cached only on the Imperva proxies. Default: false
    clientSendAgeHeader Boolean
    Send Cache-Control: max-age and Age headers. Default: false
    keyComplyVary Boolean
    Comply with Vary. Cache resources in accordance with the Vary response header. Default: false
    keyUniteNakedFullCache Boolean
    Use the Same Cache for Full and Naked Domains. For example, use the same cached resource for www.example.com/a and example.com/a. Default: false
    modeHttps String
    The resources that are cached over HTTPS, the general level applies. Default: disabled Possible values:

    • disabled - No resources are cached over HTTPS.
    • dont_include_html - Only images, css files, js files, and resources defined with the 'Cache-Control: public' header may be cached over HTTPS.
    • include_html - Same as dont_include_html, also HTML files may be cached over HTTPS.
    • include_all_resources - All resources may be cached over HTTPS.
    modeLevel String
    Caching level. Default: smart Possible values:

    • disabled - Turn off site caching entirely, including user-defined custom cache rules. Note: Since all other attributes require caching, it is recommended to clear all resource attributes from configuration when disabling the cache.
    • custom_cache_rules_only - Disable caching, unless specified otherwise by a custom cache rule.
    • standard - Cache according to standard HTTP headers.
    • smart - Cache according to standard HTTP headers as well as profile dynamic pages to identify and cache static content that was not marked as static. In addition to content that was marked by the site's developer / web server as static using standard HTTP headers, Imperva also profiles other resources to identify and cache static content that was not marked as such.
    • all_resources - Cache every resource on the web server for the specified amount of time. All site content is cached.
    modeTime Number
    The time, in seconds, that you set for this option determines how often the cache is refreshed. Relevant for the include_html and include_all_resources levels only.
    responseCache300x Boolean
    When this option is checked Imperva will cache 301, 302, 303, 307, and 308 redirect response headers containing the target URI. Default: false
    responseCache404Enabled Boolean
    Whether or not to cache 404 responses. Default: false
    responseCache404Time Number
    The time in seconds to cache 404 responses. Value should be divisible by 60.
    responseCacheEmptyResponses Boolean
    Cache responses that don’t have a message body. Default: false
    responseCacheHttp10Responses Boolean
    Cache HTTP 1.0 type responses that don’t include the Content-Length header or chunking. Default: false
    responseCacheResponseHeaderMode String
    The working mode for caching response headers. Default: disabled Possible values:

    • disabled
    • all - Cache all headers in responses.
    • custom - Specify which response headers should be cached along with the resource.
    responseCacheResponseHeaders List<String>
    An array of strings representing the response headers to be cached when working in custom mode. If empty, no response headers are cached. For example: ["Access-Control-Allow-Origin","Access-Control-Allow-Methods"].
    responseCacheShield Boolean
    Adds an intermediate cache between other Imperva PoPs and your origin servers to protect your servers from redundant requests. Default: false
    responseStaleContentMode String
    The working mode for serving stale content. Default: disabled Possible values:

    • disabled - Disable serving of stale content.
    • adaptive - Stale content is served for a duration of 2 to 24 hours based on the time passed since the resource was last updated.
    • custom - Serve stale content for the specified amount of time.
    responseStaleContentTime Number
    The time, in seconds, to serve stale content for when working in custom work mode.
    responseTagResponseHeader String
    Tag the response according to the value of this header. Specify which origin response header contains the cache tags in your resources.
    siteCacheConfigurationId String
    Unique identifier in the API for the Site Cache configuration. The id is identical to Site id.
    ttlPreferLastModified Boolean
    Prefer 'Last Modified' over eTag. When this option is checked, Imperva prefers using Last Modified values (if available) over eTag values (recommended on multi-server setups). Default: false
    ttlUseShortestCaching Boolean
    Use shortest caching duration in case of conflicts. By default, the longest duration is used in case of conflict between caching rules or modes. When this option is checked, Imperva uses the shortest duration in case of conflict. Default: false

    Outputs

    All input properties are implicitly available as output properties. Additionally, the SiteCacheConfiguration resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id str
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing SiteCacheConfiguration Resource

    Get an existing SiteCacheConfiguration resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: SiteCacheConfigurationState, opts?: CustomResourceOptions): SiteCacheConfiguration
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        client_comply_no_cache: Optional[bool] = None,
        client_enable_client_side_caching: Optional[bool] = None,
        client_send_age_header: Optional[bool] = None,
        key_comply_vary: Optional[bool] = None,
        key_unite_naked_full_cache: Optional[bool] = None,
        mode_https: Optional[str] = None,
        mode_level: Optional[str] = None,
        mode_time: Optional[float] = None,
        response_cache300x: Optional[bool] = None,
        response_cache404_enabled: Optional[bool] = None,
        response_cache404_time: Optional[float] = None,
        response_cache_empty_responses: Optional[bool] = None,
        response_cache_http10_responses: Optional[bool] = None,
        response_cache_response_header_mode: Optional[str] = None,
        response_cache_response_headers: Optional[Sequence[str]] = None,
        response_cache_shield: Optional[bool] = None,
        response_stale_content_mode: Optional[str] = None,
        response_stale_content_time: Optional[float] = None,
        response_tag_response_header: Optional[str] = None,
        site_cache_configuration_id: Optional[str] = None,
        site_id: Optional[float] = None,
        ttl_prefer_last_modified: Optional[bool] = None,
        ttl_use_shortest_caching: Optional[bool] = None) -> SiteCacheConfiguration
    func GetSiteCacheConfiguration(ctx *Context, name string, id IDInput, state *SiteCacheConfigurationState, opts ...ResourceOption) (*SiteCacheConfiguration, error)
    public static SiteCacheConfiguration Get(string name, Input<string> id, SiteCacheConfigurationState? state, CustomResourceOptions? opts = null)
    public static SiteCacheConfiguration get(String name, Output<String> id, SiteCacheConfigurationState state, CustomResourceOptions options)
    resources:  _:    type: incapsula:SiteCacheConfiguration    get:      id: ${id}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    ClientComplyNoCache bool
    Comply with No-Cache and Max-Age directives in client requests. By default, these cache directives are ignored. Resources are dynamically profiled and re-configured to optimize performance. Default: false
    ClientEnableClientSideCaching bool
    Cache content on client browsers or applications. When not enabled, content is cached only on the Imperva proxies. Default: false
    ClientSendAgeHeader bool
    Send Cache-Control: max-age and Age headers. Default: false
    KeyComplyVary bool
    Comply with Vary. Cache resources in accordance with the Vary response header. Default: false
    KeyUniteNakedFullCache bool
    Use the Same Cache for Full and Naked Domains. For example, use the same cached resource for www.example.com/a and example.com/a. Default: false
    ModeHttps string
    The resources that are cached over HTTPS, the general level applies. Default: disabled Possible values:

    • disabled - No resources are cached over HTTPS.
    • dont_include_html - Only images, css files, js files, and resources defined with the 'Cache-Control: public' header may be cached over HTTPS.
    • include_html - Same as dont_include_html, also HTML files may be cached over HTTPS.
    • include_all_resources - All resources may be cached over HTTPS.
    ModeLevel string
    Caching level. Default: smart Possible values:

    • disabled - Turn off site caching entirely, including user-defined custom cache rules. Note: Since all other attributes require caching, it is recommended to clear all resource attributes from configuration when disabling the cache.
    • custom_cache_rules_only - Disable caching, unless specified otherwise by a custom cache rule.
    • standard - Cache according to standard HTTP headers.
    • smart - Cache according to standard HTTP headers as well as profile dynamic pages to identify and cache static content that was not marked as static. In addition to content that was marked by the site's developer / web server as static using standard HTTP headers, Imperva also profiles other resources to identify and cache static content that was not marked as such.
    • all_resources - Cache every resource on the web server for the specified amount of time. All site content is cached.
    ModeTime double
    The time, in seconds, that you set for this option determines how often the cache is refreshed. Relevant for the include_html and include_all_resources levels only.
    ResponseCache300x bool
    When this option is checked Imperva will cache 301, 302, 303, 307, and 308 redirect response headers containing the target URI. Default: false
    ResponseCache404Enabled bool
    Whether or not to cache 404 responses. Default: false
    ResponseCache404Time double
    The time in seconds to cache 404 responses. Value should be divisible by 60.
    ResponseCacheEmptyResponses bool
    Cache responses that don’t have a message body. Default: false
    ResponseCacheHttp10Responses bool
    Cache HTTP 1.0 type responses that don’t include the Content-Length header or chunking. Default: false
    ResponseCacheResponseHeaderMode string
    The working mode for caching response headers. Default: disabled Possible values:

    • disabled
    • all - Cache all headers in responses.
    • custom - Specify which response headers should be cached along with the resource.
    ResponseCacheResponseHeaders List<string>
    An array of strings representing the response headers to be cached when working in custom mode. If empty, no response headers are cached. For example: ["Access-Control-Allow-Origin","Access-Control-Allow-Methods"].
    ResponseCacheShield bool
    Adds an intermediate cache between other Imperva PoPs and your origin servers to protect your servers from redundant requests. Default: false
    ResponseStaleContentMode string
    The working mode for serving stale content. Default: disabled Possible values:

    • disabled - Disable serving of stale content.
    • adaptive - Stale content is served for a duration of 2 to 24 hours based on the time passed since the resource was last updated.
    • custom - Serve stale content for the specified amount of time.
    ResponseStaleContentTime double
    The time, in seconds, to serve stale content for when working in custom work mode.
    ResponseTagResponseHeader string
    Tag the response according to the value of this header. Specify which origin response header contains the cache tags in your resources.
    SiteCacheConfigurationId string
    Unique identifier in the API for the Site Cache configuration. The id is identical to Site id.
    SiteId double
    Numeric identifier of the site to operate on.
    TtlPreferLastModified bool
    Prefer 'Last Modified' over eTag. When this option is checked, Imperva prefers using Last Modified values (if available) over eTag values (recommended on multi-server setups). Default: false
    TtlUseShortestCaching bool
    Use shortest caching duration in case of conflicts. By default, the longest duration is used in case of conflict between caching rules or modes. When this option is checked, Imperva uses the shortest duration in case of conflict. Default: false
    ClientComplyNoCache bool
    Comply with No-Cache and Max-Age directives in client requests. By default, these cache directives are ignored. Resources are dynamically profiled and re-configured to optimize performance. Default: false
    ClientEnableClientSideCaching bool
    Cache content on client browsers or applications. When not enabled, content is cached only on the Imperva proxies. Default: false
    ClientSendAgeHeader bool
    Send Cache-Control: max-age and Age headers. Default: false
    KeyComplyVary bool
    Comply with Vary. Cache resources in accordance with the Vary response header. Default: false
    KeyUniteNakedFullCache bool
    Use the Same Cache for Full and Naked Domains. For example, use the same cached resource for www.example.com/a and example.com/a. Default: false
    ModeHttps string
    The resources that are cached over HTTPS, the general level applies. Default: disabled Possible values:

    • disabled - No resources are cached over HTTPS.
    • dont_include_html - Only images, css files, js files, and resources defined with the 'Cache-Control: public' header may be cached over HTTPS.
    • include_html - Same as dont_include_html, also HTML files may be cached over HTTPS.
    • include_all_resources - All resources may be cached over HTTPS.
    ModeLevel string
    Caching level. Default: smart Possible values:

    • disabled - Turn off site caching entirely, including user-defined custom cache rules. Note: Since all other attributes require caching, it is recommended to clear all resource attributes from configuration when disabling the cache.
    • custom_cache_rules_only - Disable caching, unless specified otherwise by a custom cache rule.
    • standard - Cache according to standard HTTP headers.
    • smart - Cache according to standard HTTP headers as well as profile dynamic pages to identify and cache static content that was not marked as static. In addition to content that was marked by the site's developer / web server as static using standard HTTP headers, Imperva also profiles other resources to identify and cache static content that was not marked as such.
    • all_resources - Cache every resource on the web server for the specified amount of time. All site content is cached.
    ModeTime float64
    The time, in seconds, that you set for this option determines how often the cache is refreshed. Relevant for the include_html and include_all_resources levels only.
    ResponseCache300x bool
    When this option is checked Imperva will cache 301, 302, 303, 307, and 308 redirect response headers containing the target URI. Default: false
    ResponseCache404Enabled bool
    Whether or not to cache 404 responses. Default: false
    ResponseCache404Time float64
    The time in seconds to cache 404 responses. Value should be divisible by 60.
    ResponseCacheEmptyResponses bool
    Cache responses that don’t have a message body. Default: false
    ResponseCacheHttp10Responses bool
    Cache HTTP 1.0 type responses that don’t include the Content-Length header or chunking. Default: false
    ResponseCacheResponseHeaderMode string
    The working mode for caching response headers. Default: disabled Possible values:

    • disabled
    • all - Cache all headers in responses.
    • custom - Specify which response headers should be cached along with the resource.
    ResponseCacheResponseHeaders []string
    An array of strings representing the response headers to be cached when working in custom mode. If empty, no response headers are cached. For example: ["Access-Control-Allow-Origin","Access-Control-Allow-Methods"].
    ResponseCacheShield bool
    Adds an intermediate cache between other Imperva PoPs and your origin servers to protect your servers from redundant requests. Default: false
    ResponseStaleContentMode string
    The working mode for serving stale content. Default: disabled Possible values:

    • disabled - Disable serving of stale content.
    • adaptive - Stale content is served for a duration of 2 to 24 hours based on the time passed since the resource was last updated.
    • custom - Serve stale content for the specified amount of time.
    ResponseStaleContentTime float64
    The time, in seconds, to serve stale content for when working in custom work mode.
    ResponseTagResponseHeader string
    Tag the response according to the value of this header. Specify which origin response header contains the cache tags in your resources.
    SiteCacheConfigurationId string
    Unique identifier in the API for the Site Cache configuration. The id is identical to Site id.
    SiteId float64
    Numeric identifier of the site to operate on.
    TtlPreferLastModified bool
    Prefer 'Last Modified' over eTag. When this option is checked, Imperva prefers using Last Modified values (if available) over eTag values (recommended on multi-server setups). Default: false
    TtlUseShortestCaching bool
    Use shortest caching duration in case of conflicts. By default, the longest duration is used in case of conflict between caching rules or modes. When this option is checked, Imperva uses the shortest duration in case of conflict. Default: false
    clientComplyNoCache Boolean
    Comply with No-Cache and Max-Age directives in client requests. By default, these cache directives are ignored. Resources are dynamically profiled and re-configured to optimize performance. Default: false
    clientEnableClientSideCaching Boolean
    Cache content on client browsers or applications. When not enabled, content is cached only on the Imperva proxies. Default: false
    clientSendAgeHeader Boolean
    Send Cache-Control: max-age and Age headers. Default: false
    keyComplyVary Boolean
    Comply with Vary. Cache resources in accordance with the Vary response header. Default: false
    keyUniteNakedFullCache Boolean
    Use the Same Cache for Full and Naked Domains. For example, use the same cached resource for www.example.com/a and example.com/a. Default: false
    modeHttps String
    The resources that are cached over HTTPS, the general level applies. Default: disabled Possible values:

    • disabled - No resources are cached over HTTPS.
    • dont_include_html - Only images, css files, js files, and resources defined with the 'Cache-Control: public' header may be cached over HTTPS.
    • include_html - Same as dont_include_html, also HTML files may be cached over HTTPS.
    • include_all_resources - All resources may be cached over HTTPS.
    modeLevel String
    Caching level. Default: smart Possible values:

    • disabled - Turn off site caching entirely, including user-defined custom cache rules. Note: Since all other attributes require caching, it is recommended to clear all resource attributes from configuration when disabling the cache.
    • custom_cache_rules_only - Disable caching, unless specified otherwise by a custom cache rule.
    • standard - Cache according to standard HTTP headers.
    • smart - Cache according to standard HTTP headers as well as profile dynamic pages to identify and cache static content that was not marked as static. In addition to content that was marked by the site's developer / web server as static using standard HTTP headers, Imperva also profiles other resources to identify and cache static content that was not marked as such.
    • all_resources - Cache every resource on the web server for the specified amount of time. All site content is cached.
    modeTime Double
    The time, in seconds, that you set for this option determines how often the cache is refreshed. Relevant for the include_html and include_all_resources levels only.
    responseCache300x Boolean
    When this option is checked Imperva will cache 301, 302, 303, 307, and 308 redirect response headers containing the target URI. Default: false
    responseCache404Enabled Boolean
    Whether or not to cache 404 responses. Default: false
    responseCache404Time Double
    The time in seconds to cache 404 responses. Value should be divisible by 60.
    responseCacheEmptyResponses Boolean
    Cache responses that don’t have a message body. Default: false
    responseCacheHttp10Responses Boolean
    Cache HTTP 1.0 type responses that don’t include the Content-Length header or chunking. Default: false
    responseCacheResponseHeaderMode String
    The working mode for caching response headers. Default: disabled Possible values:

    • disabled
    • all - Cache all headers in responses.
    • custom - Specify which response headers should be cached along with the resource.
    responseCacheResponseHeaders List<String>
    An array of strings representing the response headers to be cached when working in custom mode. If empty, no response headers are cached. For example: ["Access-Control-Allow-Origin","Access-Control-Allow-Methods"].
    responseCacheShield Boolean
    Adds an intermediate cache between other Imperva PoPs and your origin servers to protect your servers from redundant requests. Default: false
    responseStaleContentMode String
    The working mode for serving stale content. Default: disabled Possible values:

    • disabled - Disable serving of stale content.
    • adaptive - Stale content is served for a duration of 2 to 24 hours based on the time passed since the resource was last updated.
    • custom - Serve stale content for the specified amount of time.
    responseStaleContentTime Double
    The time, in seconds, to serve stale content for when working in custom work mode.
    responseTagResponseHeader String
    Tag the response according to the value of this header. Specify which origin response header contains the cache tags in your resources.
    siteCacheConfigurationId String
    Unique identifier in the API for the Site Cache configuration. The id is identical to Site id.
    siteId Double
    Numeric identifier of the site to operate on.
    ttlPreferLastModified Boolean
    Prefer 'Last Modified' over eTag. When this option is checked, Imperva prefers using Last Modified values (if available) over eTag values (recommended on multi-server setups). Default: false
    ttlUseShortestCaching Boolean
    Use shortest caching duration in case of conflicts. By default, the longest duration is used in case of conflict between caching rules or modes. When this option is checked, Imperva uses the shortest duration in case of conflict. Default: false
    clientComplyNoCache boolean
    Comply with No-Cache and Max-Age directives in client requests. By default, these cache directives are ignored. Resources are dynamically profiled and re-configured to optimize performance. Default: false
    clientEnableClientSideCaching boolean
    Cache content on client browsers or applications. When not enabled, content is cached only on the Imperva proxies. Default: false
    clientSendAgeHeader boolean
    Send Cache-Control: max-age and Age headers. Default: false
    keyComplyVary boolean
    Comply with Vary. Cache resources in accordance with the Vary response header. Default: false
    keyUniteNakedFullCache boolean
    Use the Same Cache for Full and Naked Domains. For example, use the same cached resource for www.example.com/a and example.com/a. Default: false
    modeHttps string
    The resources that are cached over HTTPS, the general level applies. Default: disabled Possible values:

    • disabled - No resources are cached over HTTPS.
    • dont_include_html - Only images, css files, js files, and resources defined with the 'Cache-Control: public' header may be cached over HTTPS.
    • include_html - Same as dont_include_html, also HTML files may be cached over HTTPS.
    • include_all_resources - All resources may be cached over HTTPS.
    modeLevel string
    Caching level. Default: smart Possible values:

    • disabled - Turn off site caching entirely, including user-defined custom cache rules. Note: Since all other attributes require caching, it is recommended to clear all resource attributes from configuration when disabling the cache.
    • custom_cache_rules_only - Disable caching, unless specified otherwise by a custom cache rule.
    • standard - Cache according to standard HTTP headers.
    • smart - Cache according to standard HTTP headers as well as profile dynamic pages to identify and cache static content that was not marked as static. In addition to content that was marked by the site's developer / web server as static using standard HTTP headers, Imperva also profiles other resources to identify and cache static content that was not marked as such.
    • all_resources - Cache every resource on the web server for the specified amount of time. All site content is cached.
    modeTime number
    The time, in seconds, that you set for this option determines how often the cache is refreshed. Relevant for the include_html and include_all_resources levels only.
    responseCache300x boolean
    When this option is checked Imperva will cache 301, 302, 303, 307, and 308 redirect response headers containing the target URI. Default: false
    responseCache404Enabled boolean
    Whether or not to cache 404 responses. Default: false
    responseCache404Time number
    The time in seconds to cache 404 responses. Value should be divisible by 60.
    responseCacheEmptyResponses boolean
    Cache responses that don’t have a message body. Default: false
    responseCacheHttp10Responses boolean
    Cache HTTP 1.0 type responses that don’t include the Content-Length header or chunking. Default: false
    responseCacheResponseHeaderMode string
    The working mode for caching response headers. Default: disabled Possible values:

    • disabled
    • all - Cache all headers in responses.
    • custom - Specify which response headers should be cached along with the resource.
    responseCacheResponseHeaders string[]
    An array of strings representing the response headers to be cached when working in custom mode. If empty, no response headers are cached. For example: ["Access-Control-Allow-Origin","Access-Control-Allow-Methods"].
    responseCacheShield boolean
    Adds an intermediate cache between other Imperva PoPs and your origin servers to protect your servers from redundant requests. Default: false
    responseStaleContentMode string
    The working mode for serving stale content. Default: disabled Possible values:

    • disabled - Disable serving of stale content.
    • adaptive - Stale content is served for a duration of 2 to 24 hours based on the time passed since the resource was last updated.
    • custom - Serve stale content for the specified amount of time.
    responseStaleContentTime number
    The time, in seconds, to serve stale content for when working in custom work mode.
    responseTagResponseHeader string
    Tag the response according to the value of this header. Specify which origin response header contains the cache tags in your resources.
    siteCacheConfigurationId string
    Unique identifier in the API for the Site Cache configuration. The id is identical to Site id.
    siteId number
    Numeric identifier of the site to operate on.
    ttlPreferLastModified boolean
    Prefer 'Last Modified' over eTag. When this option is checked, Imperva prefers using Last Modified values (if available) over eTag values (recommended on multi-server setups). Default: false
    ttlUseShortestCaching boolean
    Use shortest caching duration in case of conflicts. By default, the longest duration is used in case of conflict between caching rules or modes. When this option is checked, Imperva uses the shortest duration in case of conflict. Default: false
    client_comply_no_cache bool
    Comply with No-Cache and Max-Age directives in client requests. By default, these cache directives are ignored. Resources are dynamically profiled and re-configured to optimize performance. Default: false
    client_enable_client_side_caching bool
    Cache content on client browsers or applications. When not enabled, content is cached only on the Imperva proxies. Default: false
    client_send_age_header bool
    Send Cache-Control: max-age and Age headers. Default: false
    key_comply_vary bool
    Comply with Vary. Cache resources in accordance with the Vary response header. Default: false
    key_unite_naked_full_cache bool
    Use the Same Cache for Full and Naked Domains. For example, use the same cached resource for www.example.com/a and example.com/a. Default: false
    mode_https str
    The resources that are cached over HTTPS, the general level applies. Default: disabled Possible values:

    • disabled - No resources are cached over HTTPS.
    • dont_include_html - Only images, css files, js files, and resources defined with the 'Cache-Control: public' header may be cached over HTTPS.
    • include_html - Same as dont_include_html, also HTML files may be cached over HTTPS.
    • include_all_resources - All resources may be cached over HTTPS.
    mode_level str
    Caching level. Default: smart Possible values:

    • disabled - Turn off site caching entirely, including user-defined custom cache rules. Note: Since all other attributes require caching, it is recommended to clear all resource attributes from configuration when disabling the cache.
    • custom_cache_rules_only - Disable caching, unless specified otherwise by a custom cache rule.
    • standard - Cache according to standard HTTP headers.
    • smart - Cache according to standard HTTP headers as well as profile dynamic pages to identify and cache static content that was not marked as static. In addition to content that was marked by the site's developer / web server as static using standard HTTP headers, Imperva also profiles other resources to identify and cache static content that was not marked as such.
    • all_resources - Cache every resource on the web server for the specified amount of time. All site content is cached.
    mode_time float
    The time, in seconds, that you set for this option determines how often the cache is refreshed. Relevant for the include_html and include_all_resources levels only.
    response_cache300x bool
    When this option is checked Imperva will cache 301, 302, 303, 307, and 308 redirect response headers containing the target URI. Default: false
    response_cache404_enabled bool
    Whether or not to cache 404 responses. Default: false
    response_cache404_time float
    The time in seconds to cache 404 responses. Value should be divisible by 60.
    response_cache_empty_responses bool
    Cache responses that don’t have a message body. Default: false
    response_cache_http10_responses bool
    Cache HTTP 1.0 type responses that don’t include the Content-Length header or chunking. Default: false
    response_cache_response_header_mode str
    The working mode for caching response headers. Default: disabled Possible values:

    • disabled
    • all - Cache all headers in responses.
    • custom - Specify which response headers should be cached along with the resource.
    response_cache_response_headers Sequence[str]
    An array of strings representing the response headers to be cached when working in custom mode. If empty, no response headers are cached. For example: ["Access-Control-Allow-Origin","Access-Control-Allow-Methods"].
    response_cache_shield bool
    Adds an intermediate cache between other Imperva PoPs and your origin servers to protect your servers from redundant requests. Default: false
    response_stale_content_mode str
    The working mode for serving stale content. Default: disabled Possible values:

    • disabled - Disable serving of stale content.
    • adaptive - Stale content is served for a duration of 2 to 24 hours based on the time passed since the resource was last updated.
    • custom - Serve stale content for the specified amount of time.
    response_stale_content_time float
    The time, in seconds, to serve stale content for when working in custom work mode.
    response_tag_response_header str
    Tag the response according to the value of this header. Specify which origin response header contains the cache tags in your resources.
    site_cache_configuration_id str
    Unique identifier in the API for the Site Cache configuration. The id is identical to Site id.
    site_id float
    Numeric identifier of the site to operate on.
    ttl_prefer_last_modified bool
    Prefer 'Last Modified' over eTag. When this option is checked, Imperva prefers using Last Modified values (if available) over eTag values (recommended on multi-server setups). Default: false
    ttl_use_shortest_caching bool
    Use shortest caching duration in case of conflicts. By default, the longest duration is used in case of conflict between caching rules or modes. When this option is checked, Imperva uses the shortest duration in case of conflict. Default: false
    clientComplyNoCache Boolean
    Comply with No-Cache and Max-Age directives in client requests. By default, these cache directives are ignored. Resources are dynamically profiled and re-configured to optimize performance. Default: false
    clientEnableClientSideCaching Boolean
    Cache content on client browsers or applications. When not enabled, content is cached only on the Imperva proxies. Default: false
    clientSendAgeHeader Boolean
    Send Cache-Control: max-age and Age headers. Default: false
    keyComplyVary Boolean
    Comply with Vary. Cache resources in accordance with the Vary response header. Default: false
    keyUniteNakedFullCache Boolean
    Use the Same Cache for Full and Naked Domains. For example, use the same cached resource for www.example.com/a and example.com/a. Default: false
    modeHttps String
    The resources that are cached over HTTPS, the general level applies. Default: disabled Possible values:

    • disabled - No resources are cached over HTTPS.
    • dont_include_html - Only images, css files, js files, and resources defined with the 'Cache-Control: public' header may be cached over HTTPS.
    • include_html - Same as dont_include_html, also HTML files may be cached over HTTPS.
    • include_all_resources - All resources may be cached over HTTPS.
    modeLevel String
    Caching level. Default: smart Possible values:

    • disabled - Turn off site caching entirely, including user-defined custom cache rules. Note: Since all other attributes require caching, it is recommended to clear all resource attributes from configuration when disabling the cache.
    • custom_cache_rules_only - Disable caching, unless specified otherwise by a custom cache rule.
    • standard - Cache according to standard HTTP headers.
    • smart - Cache according to standard HTTP headers as well as profile dynamic pages to identify and cache static content that was not marked as static. In addition to content that was marked by the site's developer / web server as static using standard HTTP headers, Imperva also profiles other resources to identify and cache static content that was not marked as such.
    • all_resources - Cache every resource on the web server for the specified amount of time. All site content is cached.
    modeTime Number
    The time, in seconds, that you set for this option determines how often the cache is refreshed. Relevant for the include_html and include_all_resources levels only.
    responseCache300x Boolean
    When this option is checked Imperva will cache 301, 302, 303, 307, and 308 redirect response headers containing the target URI. Default: false
    responseCache404Enabled Boolean
    Whether or not to cache 404 responses. Default: false
    responseCache404Time Number
    The time in seconds to cache 404 responses. Value should be divisible by 60.
    responseCacheEmptyResponses Boolean
    Cache responses that don’t have a message body. Default: false
    responseCacheHttp10Responses Boolean
    Cache HTTP 1.0 type responses that don’t include the Content-Length header or chunking. Default: false
    responseCacheResponseHeaderMode String
    The working mode for caching response headers. Default: disabled Possible values:

    • disabled
    • all - Cache all headers in responses.
    • custom - Specify which response headers should be cached along with the resource.
    responseCacheResponseHeaders List<String>
    An array of strings representing the response headers to be cached when working in custom mode. If empty, no response headers are cached. For example: ["Access-Control-Allow-Origin","Access-Control-Allow-Methods"].
    responseCacheShield Boolean
    Adds an intermediate cache between other Imperva PoPs and your origin servers to protect your servers from redundant requests. Default: false
    responseStaleContentMode String
    The working mode for serving stale content. Default: disabled Possible values:

    • disabled - Disable serving of stale content.
    • adaptive - Stale content is served for a duration of 2 to 24 hours based on the time passed since the resource was last updated.
    • custom - Serve stale content for the specified amount of time.
    responseStaleContentTime Number
    The time, in seconds, to serve stale content for when working in custom work mode.
    responseTagResponseHeader String
    Tag the response according to the value of this header. Specify which origin response header contains the cache tags in your resources.
    siteCacheConfigurationId String
    Unique identifier in the API for the Site Cache configuration. The id is identical to Site id.
    siteId Number
    Numeric identifier of the site to operate on.
    ttlPreferLastModified Boolean
    Prefer 'Last Modified' over eTag. When this option is checked, Imperva prefers using Last Modified values (if available) over eTag values (recommended on multi-server setups). Default: false
    ttlUseShortestCaching Boolean
    Use shortest caching duration in case of conflicts. By default, the longest duration is used in case of conflict between caching rules or modes. When this option is checked, Imperva uses the shortest duration in case of conflict. Default: false

    Import

    Site Cache Configuration can be imported using the id, e.g.:

    $ pulumi import incapsula:index/siteCacheConfiguration:SiteCacheConfiguration example_site_cache_configuration 1234

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    incapsula imperva/terraform-provider-incapsula
    License
    Notes
    This Pulumi package is based on the incapsula Terraform Provider.
    incapsula logo
    incapsula 3.33.0 published on Wednesday, Apr 30, 2025 by imperva
    imperva/terraform-provider-incapsula