1. Packages
  2. Fastly Provider
  3. API Docs
  4. ComputeAclEntries
Viewing docs for Fastly v11.4.1
published on Friday, Feb 27, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-fastly

fastly.ComputeAclEntries

fastly logo
Viewing docs for Fastly v11.4.1
published on Friday, Feb 27, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-fastly

    The fastly.ComputeAclEntries resource allows you to manage CIDR-based allow/block rules (ACL entries) inside a Fastly Compute ACL.

    By default, Terraform does not continue to manage the entries after the initial pulumi up. This allows you to make changes to ACL entries outside of Terraform using the Fastly API or Fastly CLI) without Terraform resetting them.

    To have Terraform continue managing the entries after creation (e.g., deleting any entries not defined in the config), set manage_entries </span>= true.

    Note: Use manage_entries </span>= true cautiously. Terraform will overwrite external changes and delete any unmanaged entries.

    Example Usage

    Basic usage (with seeded values, unmanaged after initial apply):

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

// IMPORTANT: Deleting a Compute ACL requires first deleting its resource_link.
// This requires a two-step `pulumi up` as we can't guarantee deletion order.
const exampleComputeAcl = new fastly.ComputeAcl("example", {name: "my_compute_acl"});
const exampleComputeAclEntries = new fastly.ComputeAclEntries("example", {
    computeAclId: exampleComputeAcl.id,
    entries: {
        "192.0.2.0/24": "ALLOW",
        "198.51.100.0/24": "BLOCK",
    },
});
const example = fastly.getPackageHash({
    filename: "package.tar.gz",
});
const exampleServiceCompute = new fastly.ServiceCompute("example", {
    name: "my_compute_service",
    domains: [{
        name: "demo.example.com",
    }],
    "package": {
        filename: "package.tar.gz",
        sourceCodeHash: example.then(example => example.hash),
    },
    resourceLinks: [{
        name: "my_acl_link",
        resourceId: exampleComputeAcl.id,
    }],
    forceDestroy: true,
});

    import pulumi
import pulumi_fastly as fastly

# IMPORTANT: Deleting a Compute ACL requires first deleting its resource_link.
# This requires a two-step `pulumi up` as we can't guarantee deletion order.
example_compute_acl = fastly.ComputeAcl("example", name="my_compute_acl")
example_compute_acl_entries = fastly.ComputeAclEntries("example",
    compute_acl_id=example_compute_acl.id,
    entries={
        "192.0.2.0/24": "ALLOW",
        "198.51.100.0/24": "BLOCK",
    })
example = fastly.get_package_hash(filename="package.tar.gz")
example_service_compute = fastly.ServiceCompute("example",
    name="my_compute_service",
    domains=[{
        "name": "demo.example.com",
    }],
    package={
        "filename": "package.tar.gz",
        "source_code_hash": example.hash,
    },
    resource_links=[{
        "name": "my_acl_link",
        "resource_id": example_compute_acl.id,
    }],
    force_destroy=True)

    package main

import (
	"github.com/pulumi/pulumi-fastly/sdk/v11/go/fastly"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// IMPORTANT: Deleting a Compute ACL requires first deleting its resource_link.
		// This requires a two-step `pulumi up` as we can't guarantee deletion order.
		exampleComputeAcl, err := fastly.NewComputeAcl(ctx, "example", &fastly.ComputeAclArgs{
			Name: pulumi.String("my_compute_acl"),
		})
		if err != nil {
			return err
		}
		_, err = fastly.NewComputeAclEntries(ctx, "example", &fastly.ComputeAclEntriesArgs{
			ComputeAclId: exampleComputeAcl.ID(),
			Entries: pulumi.StringMap{
				"192.0.2.0/24":    pulumi.String("ALLOW"),
				"198.51.100.0/24": pulumi.String("BLOCK"),
			},
		})
		if err != nil {
			return err
		}
		example, err := fastly.GetPackageHash(ctx, &fastly.GetPackageHashArgs{
			Filename: pulumi.StringRef("package.tar.gz"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = fastly.NewServiceCompute(ctx, "example", &fastly.ServiceComputeArgs{
			Name: pulumi.String("my_compute_service"),
			Domains: fastly.ServiceComputeDomainArray{
				&fastly.ServiceComputeDomainArgs{
					Name: pulumi.String("demo.example.com"),
				},
			},
			Package: &fastly.ServiceComputePackageArgs{
				Filename:       pulumi.String("package.tar.gz"),
				SourceCodeHash: pulumi.String(example.Hash),
			},
			ResourceLinks: fastly.ServiceComputeResourceLinkArray{
				&fastly.ServiceComputeResourceLinkArgs{
					Name:       pulumi.String("my_acl_link"),
					ResourceId: exampleComputeAcl.ID(),
				},
			},
			ForceDestroy: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // IMPORTANT: Deleting a Compute ACL requires first deleting its resource_link.
    // This requires a two-step `pulumi up` as we can't guarantee deletion order.
    var exampleComputeAcl = new Fastly.ComputeAcl("example", new()
    {
        Name = "my_compute_acl",
    });

    var exampleComputeAclEntries = new Fastly.ComputeAclEntries("example", new()
    {
        ComputeAclId = exampleComputeAcl.Id,
        Entries = 
        {
            { "192.0.2.0/24", "ALLOW" },
            { "198.51.100.0/24", "BLOCK" },
        },
    });

    var example = Fastly.GetPackageHash.Invoke(new()
    {
        Filename = "package.tar.gz",
    });

    var exampleServiceCompute = new Fastly.ServiceCompute("example", new()
    {
        Name = "my_compute_service",
        Domains = new[]
        {
            new Fastly.Inputs.ServiceComputeDomainArgs
            {
                Name = "demo.example.com",
            },
        },
        Package = new Fastly.Inputs.ServiceComputePackageArgs
        {
            Filename = "package.tar.gz",
            SourceCodeHash = example.Apply(getPackageHashResult => getPackageHashResult.Hash),
        },
        ResourceLinks = new[]
        {
            new Fastly.Inputs.ServiceComputeResourceLinkArgs
            {
                Name = "my_acl_link",
                ResourceId = exampleComputeAcl.Id,
            },
        },
        ForceDestroy = true,
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.fastly.ComputeAcl;
import com.pulumi.fastly.ComputeAclArgs;
import com.pulumi.fastly.ComputeAclEntries;
import com.pulumi.fastly.ComputeAclEntriesArgs;
import com.pulumi.fastly.FastlyFunctions;
import com.pulumi.fastly.inputs.GetPackageHashArgs;
import com.pulumi.fastly.ServiceCompute;
import com.pulumi.fastly.ServiceComputeArgs;
import com.pulumi.fastly.inputs.ServiceComputeDomainArgs;
import com.pulumi.fastly.inputs.ServiceComputePackageArgs;
import com.pulumi.fastly.inputs.ServiceComputeResourceLinkArgs;
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) {
        // IMPORTANT: Deleting a Compute ACL requires first deleting its resource_link.
        // This requires a two-step `pulumi up` as we can't guarantee deletion order.
        var exampleComputeAcl = new ComputeAcl("exampleComputeAcl", ComputeAclArgs.builder()
            .name("my_compute_acl")
            .build());

        var exampleComputeAclEntries = new ComputeAclEntries("exampleComputeAclEntries", ComputeAclEntriesArgs.builder()
            .computeAclId(exampleComputeAcl.id())
            .entries(Map.ofEntries(
                Map.entry("192.0.2.0/24", "ALLOW"),
                Map.entry("198.51.100.0/24", "BLOCK")
            ))
            .build());

        final var example = FastlyFunctions.getPackageHash(GetPackageHashArgs.builder()
            .filename("package.tar.gz")
            .build());

        var exampleServiceCompute = new ServiceCompute("exampleServiceCompute", ServiceComputeArgs.builder()
            .name("my_compute_service")
            .domains(ServiceComputeDomainArgs.builder()
                .name("demo.example.com")
                .build())
            .package_(ServiceComputePackageArgs.builder()
                .filename("package.tar.gz")
                .sourceCodeHash(example.hash())
                .build())
            .resourceLinks(ServiceComputeResourceLinkArgs.builder()
                .name("my_acl_link")
                .resourceId(exampleComputeAcl.id())
                .build())
            .forceDestroy(true)
            .build());

    }
}

    resources:
  # IMPORTANT: Deleting a Compute ACL requires first deleting its resource_link.
  # This requires a two-step `pulumi up` as we can't guarantee deletion order.
  exampleComputeAcl:
    type: fastly:ComputeAcl
    name: example
    properties:
      name: my_compute_acl
  exampleComputeAclEntries:
    type: fastly:ComputeAclEntries
    name: example
    properties:
      computeAclId: ${exampleComputeAcl.id}
      entries:
        192.0.2.0/24: ALLOW
        198.51.100.0/24: BLOCK
  exampleServiceCompute:
    type: fastly:ServiceCompute
    name: example
    properties:
      name: my_compute_service
      domains:
        - name: demo.example.com
      package:
        filename: package.tar.gz
        sourceCodeHash: ${example.hash}
      resourceLinks:
        - name: my_acl_link
          resourceId: ${exampleComputeAcl.id}
      forceDestroy: true
variables:
  example:
    fn::invoke:
      function: fastly:getPackageHash
      arguments:
        filename: package.tar.gz

    Terraform-managed usage (where Terraform controls entries long-term):

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

// IMPORTANT: Deleting a Compute ACL requires first deleting its resource_link.
// This requires a two-step `pulumi up` as we can't guarantee deletion order.
const exampleComputeAcl = new fastly.ComputeAcl("example", {name: "my_compute_acl"});
const exampleComputeAclEntries = new fastly.ComputeAclEntries("example", {
    computeAclId: exampleComputeAcl.id,
    entries: {
        "203.0.113.0/24": "BLOCK",
        "198.51.100.0/24": "ALLOW",
    },
    manageEntries: true,
});
const example = fastly.getPackageHash({
    filename: "package.tar.gz",
});
const exampleServiceCompute = new fastly.ServiceCompute("example", {
    name: "my_compute_service",
    domains: [{
        name: "demo.example.com",
    }],
    "package": {
        filename: "package.tar.gz",
        sourceCodeHash: example.then(example => example.hash),
    },
    resourceLinks: [{
        name: "my_acl_link",
        resourceId: exampleComputeAcl.id,
    }],
    forceDestroy: true,
});

    import pulumi
import pulumi_fastly as fastly

# IMPORTANT: Deleting a Compute ACL requires first deleting its resource_link.
# This requires a two-step `pulumi up` as we can't guarantee deletion order.
example_compute_acl = fastly.ComputeAcl("example", name="my_compute_acl")
example_compute_acl_entries = fastly.ComputeAclEntries("example",
    compute_acl_id=example_compute_acl.id,
    entries={
        "203.0.113.0/24": "BLOCK",
        "198.51.100.0/24": "ALLOW",
    },
    manage_entries=True)
example = fastly.get_package_hash(filename="package.tar.gz")
example_service_compute = fastly.ServiceCompute("example",
    name="my_compute_service",
    domains=[{
        "name": "demo.example.com",
    }],
    package={
        "filename": "package.tar.gz",
        "source_code_hash": example.hash,
    },
    resource_links=[{
        "name": "my_acl_link",
        "resource_id": example_compute_acl.id,
    }],
    force_destroy=True)

    package main

import (
	"github.com/pulumi/pulumi-fastly/sdk/v11/go/fastly"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// IMPORTANT: Deleting a Compute ACL requires first deleting its resource_link.
		// This requires a two-step `pulumi up` as we can't guarantee deletion order.
		exampleComputeAcl, err := fastly.NewComputeAcl(ctx, "example", &fastly.ComputeAclArgs{
			Name: pulumi.String("my_compute_acl"),
		})
		if err != nil {
			return err
		}
		_, err = fastly.NewComputeAclEntries(ctx, "example", &fastly.ComputeAclEntriesArgs{
			ComputeAclId: exampleComputeAcl.ID(),
			Entries: pulumi.StringMap{
				"203.0.113.0/24":  pulumi.String("BLOCK"),
				"198.51.100.0/24": pulumi.String("ALLOW"),
			},
			ManageEntries: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		example, err := fastly.GetPackageHash(ctx, &fastly.GetPackageHashArgs{
			Filename: pulumi.StringRef("package.tar.gz"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = fastly.NewServiceCompute(ctx, "example", &fastly.ServiceComputeArgs{
			Name: pulumi.String("my_compute_service"),
			Domains: fastly.ServiceComputeDomainArray{
				&fastly.ServiceComputeDomainArgs{
					Name: pulumi.String("demo.example.com"),
				},
			},
			Package: &fastly.ServiceComputePackageArgs{
				Filename:       pulumi.String("package.tar.gz"),
				SourceCodeHash: pulumi.String(example.Hash),
			},
			ResourceLinks: fastly.ServiceComputeResourceLinkArray{
				&fastly.ServiceComputeResourceLinkArgs{
					Name:       pulumi.String("my_acl_link"),
					ResourceId: exampleComputeAcl.ID(),
				},
			},
			ForceDestroy: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // IMPORTANT: Deleting a Compute ACL requires first deleting its resource_link.
    // This requires a two-step `pulumi up` as we can't guarantee deletion order.
    var exampleComputeAcl = new Fastly.ComputeAcl("example", new()
    {
        Name = "my_compute_acl",
    });

    var exampleComputeAclEntries = new Fastly.ComputeAclEntries("example", new()
    {
        ComputeAclId = exampleComputeAcl.Id,
        Entries = 
        {
            { "203.0.113.0/24", "BLOCK" },
            { "198.51.100.0/24", "ALLOW" },
        },
        ManageEntries = true,
    });

    var example = Fastly.GetPackageHash.Invoke(new()
    {
        Filename = "package.tar.gz",
    });

    var exampleServiceCompute = new Fastly.ServiceCompute("example", new()
    {
        Name = "my_compute_service",
        Domains = new[]
        {
            new Fastly.Inputs.ServiceComputeDomainArgs
            {
                Name = "demo.example.com",
            },
        },
        Package = new Fastly.Inputs.ServiceComputePackageArgs
        {
            Filename = "package.tar.gz",
            SourceCodeHash = example.Apply(getPackageHashResult => getPackageHashResult.Hash),
        },
        ResourceLinks = new[]
        {
            new Fastly.Inputs.ServiceComputeResourceLinkArgs
            {
                Name = "my_acl_link",
                ResourceId = exampleComputeAcl.Id,
            },
        },
        ForceDestroy = true,
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.fastly.ComputeAcl;
import com.pulumi.fastly.ComputeAclArgs;
import com.pulumi.fastly.ComputeAclEntries;
import com.pulumi.fastly.ComputeAclEntriesArgs;
import com.pulumi.fastly.FastlyFunctions;
import com.pulumi.fastly.inputs.GetPackageHashArgs;
import com.pulumi.fastly.ServiceCompute;
import com.pulumi.fastly.ServiceComputeArgs;
import com.pulumi.fastly.inputs.ServiceComputeDomainArgs;
import com.pulumi.fastly.inputs.ServiceComputePackageArgs;
import com.pulumi.fastly.inputs.ServiceComputeResourceLinkArgs;
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) {
        // IMPORTANT: Deleting a Compute ACL requires first deleting its resource_link.
        // This requires a two-step `pulumi up` as we can't guarantee deletion order.
        var exampleComputeAcl = new ComputeAcl("exampleComputeAcl", ComputeAclArgs.builder()
            .name("my_compute_acl")
            .build());

        var exampleComputeAclEntries = new ComputeAclEntries("exampleComputeAclEntries", ComputeAclEntriesArgs.builder()
            .computeAclId(exampleComputeAcl.id())
            .entries(Map.ofEntries(
                Map.entry("203.0.113.0/24", "BLOCK"),
                Map.entry("198.51.100.0/24", "ALLOW")
            ))
            .manageEntries(true)
            .build());

        final var example = FastlyFunctions.getPackageHash(GetPackageHashArgs.builder()
            .filename("package.tar.gz")
            .build());

        var exampleServiceCompute = new ServiceCompute("exampleServiceCompute", ServiceComputeArgs.builder()
            .name("my_compute_service")
            .domains(ServiceComputeDomainArgs.builder()
                .name("demo.example.com")
                .build())
            .package_(ServiceComputePackageArgs.builder()
                .filename("package.tar.gz")
                .sourceCodeHash(example.hash())
                .build())
            .resourceLinks(ServiceComputeResourceLinkArgs.builder()
                .name("my_acl_link")
                .resourceId(exampleComputeAcl.id())
                .build())
            .forceDestroy(true)
            .build());

    }
}

    resources:
  # IMPORTANT: Deleting a Compute ACL requires first deleting its resource_link.
  # This requires a two-step `pulumi up` as we can't guarantee deletion order.
  exampleComputeAcl:
    type: fastly:ComputeAcl
    name: example
    properties:
      name: my_compute_acl
  exampleComputeAclEntries:
    type: fastly:ComputeAclEntries
    name: example
    properties:
      computeAclId: ${exampleComputeAcl.id}
      entries:
        203.0.113.0/24: BLOCK
        198.51.100.0/24: ALLOW
      manageEntries: true
  exampleServiceCompute:
    type: fastly:ServiceCompute
    name: example
    properties:
      name: my_compute_service
      domains:
        - name: demo.example.com
      package:
        filename: package.tar.gz
        sourceCodeHash: ${example.hash}
      resourceLinks:
        - name: my_acl_link
          resourceId: ${exampleComputeAcl.id}
      forceDestroy: true
variables:
  example:
    fn::invoke:
      function: fastly:getPackageHash
      arguments:
        filename: package.tar.gz

    Create ComputeAclEntries Resource

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

    Constructor syntax

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

@overload
def ComputeAclEntries(resource_name: str,
                      opts: Optional[ResourceOptions] = None,
                      compute_acl_id: Optional[str] = None,
                      entries: Optional[Mapping[str, str]] = None,
                      manage_entries: Optional[bool] = None)
    func NewComputeAclEntries(ctx *Context, name string, args ComputeAclEntriesArgs, opts ...ResourceOption) (*ComputeAclEntries, error)
    public ComputeAclEntries(string name, ComputeAclEntriesArgs args, CustomResourceOptions? opts = null)
    public ComputeAclEntries(String name, ComputeAclEntriesArgs args)
public ComputeAclEntries(String name, ComputeAclEntriesArgs args, CustomResourceOptions options)

    type: fastly:ComputeAclEntries
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 ComputeAclEntriesArgs
    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 ComputeAclEntriesArgs
    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 ComputeAclEntriesArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ComputeAclEntriesArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args ComputeAclEntriesArgs
    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 computeAclEntriesResource = new Fastly.ComputeAclEntries("computeAclEntriesResource", new()
{
    ComputeAclId = "string",
    Entries = 
    {
        { "string", "string" },
    },
    ManageEntries = false,
});

    example, err := fastly.NewComputeAclEntries(ctx, "computeAclEntriesResource", &fastly.ComputeAclEntriesArgs{
	ComputeAclId: pulumi.String("string"),
	Entries: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	ManageEntries: pulumi.Bool(false),
})

    var computeAclEntriesResource = new ComputeAclEntries("computeAclEntriesResource", ComputeAclEntriesArgs.builder()
    .computeAclId("string")
    .entries(Map.of("string", "string"))
    .manageEntries(false)
    .build());

    compute_acl_entries_resource = fastly.ComputeAclEntries("computeAclEntriesResource",
    compute_acl_id="string",
    entries={
        "string": "string",
    },
    manage_entries=False)

    const computeAclEntriesResource = new fastly.ComputeAclEntries("computeAclEntriesResource", {
    computeAclId: "string",
    entries: {
        string: "string",
    },
    manageEntries: false,
});

    type: fastly:ComputeAclEntries
properties:
    computeAclId: string
    entries:
        string: string
    manageEntries: false

    ComputeAclEntries 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 ComputeAclEntries resource accepts the following input properties:

    ComputeAclId string
    Manages entries for a Fastly Compute Access Control List (ACL). To import, use the format \n\n/entries.
    Entries Dictionary<string, string>
    A map representing the entries in the Compute ACL, where the keys are the prefixes and the values are the actions (ALLOW or BLOCK).
    ManageEntries bool
    Manage the ACL entries in Terraform (default: false). If true, Terraform will ensure that the ACL's entries match the entries in the Terraform configuration.
    ComputeAclId string
    Manages entries for a Fastly Compute Access Control List (ACL). To import, use the format \n\n/entries.
    Entries map[string]string
    A map representing the entries in the Compute ACL, where the keys are the prefixes and the values are the actions (ALLOW or BLOCK).
    ManageEntries bool
    Manage the ACL entries in Terraform (default: false). If true, Terraform will ensure that the ACL's entries match the entries in the Terraform configuration.
    computeAclId String
    Manages entries for a Fastly Compute Access Control List (ACL). To import, use the format \n\n/entries.
    entries Map<String,String>
    A map representing the entries in the Compute ACL, where the keys are the prefixes and the values are the actions (ALLOW or BLOCK).
    manageEntries Boolean
    Manage the ACL entries in Terraform (default: false). If true, Terraform will ensure that the ACL's entries match the entries in the Terraform configuration.
    computeAclId string
    Manages entries for a Fastly Compute Access Control List (ACL). To import, use the format \n\n/entries.
    entries {[key: string]: string}
    A map representing the entries in the Compute ACL, where the keys are the prefixes and the values are the actions (ALLOW or BLOCK).
    manageEntries boolean
    Manage the ACL entries in Terraform (default: false). If true, Terraform will ensure that the ACL's entries match the entries in the Terraform configuration.
    compute_acl_id str
    Manages entries for a Fastly Compute Access Control List (ACL). To import, use the format \n\n/entries.
    entries Mapping[str, str]
    A map representing the entries in the Compute ACL, where the keys are the prefixes and the values are the actions (ALLOW or BLOCK).
    manage_entries bool
    Manage the ACL entries in Terraform (default: false). If true, Terraform will ensure that the ACL's entries match the entries in the Terraform configuration.
    computeAclId String
    Manages entries for a Fastly Compute Access Control List (ACL). To import, use the format \n\n/entries.
    entries Map<String>
    A map representing the entries in the Compute ACL, where the keys are the prefixes and the values are the actions (ALLOW or BLOCK).
    manageEntries Boolean
    Manage the ACL entries in Terraform (default: false). If true, Terraform will ensure that the ACL's entries match the entries in the Terraform configuration.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the ComputeAclEntries 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 ComputeAclEntries Resource

    Get an existing ComputeAclEntries 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?: ComputeAclEntriesState, opts?: CustomResourceOptions): ComputeAclEntries
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        compute_acl_id: Optional[str] = None,
        entries: Optional[Mapping[str, str]] = None,
        manage_entries: Optional[bool] = None) -> ComputeAclEntries
    func GetComputeAclEntries(ctx *Context, name string, id IDInput, state *ComputeAclEntriesState, opts ...ResourceOption) (*ComputeAclEntries, error)
    public static ComputeAclEntries Get(string name, Input<string> id, ComputeAclEntriesState? state, CustomResourceOptions? opts = null)
    public static ComputeAclEntries get(String name, Output<String> id, ComputeAclEntriesState state, CustomResourceOptions options)
    resources:  _:    type: fastly:ComputeAclEntries    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:
    ComputeAclId string
    Manages entries for a Fastly Compute Access Control List (ACL). To import, use the format \n\n/entries.
    Entries Dictionary<string, string>
    A map representing the entries in the Compute ACL, where the keys are the prefixes and the values are the actions (ALLOW or BLOCK).
    ManageEntries bool
    Manage the ACL entries in Terraform (default: false). If true, Terraform will ensure that the ACL's entries match the entries in the Terraform configuration.
    ComputeAclId string
    Manages entries for a Fastly Compute Access Control List (ACL). To import, use the format \n\n/entries.
    Entries map[string]string
    A map representing the entries in the Compute ACL, where the keys are the prefixes and the values are the actions (ALLOW or BLOCK).
    ManageEntries bool
    Manage the ACL entries in Terraform (default: false). If true, Terraform will ensure that the ACL's entries match the entries in the Terraform configuration.
    computeAclId String
    Manages entries for a Fastly Compute Access Control List (ACL). To import, use the format \n\n/entries.
    entries Map<String,String>
    A map representing the entries in the Compute ACL, where the keys are the prefixes and the values are the actions (ALLOW or BLOCK).
    manageEntries Boolean
    Manage the ACL entries in Terraform (default: false). If true, Terraform will ensure that the ACL's entries match the entries in the Terraform configuration.
    computeAclId string
    Manages entries for a Fastly Compute Access Control List (ACL). To import, use the format \n\n/entries.
    entries {[key: string]: string}
    A map representing the entries in the Compute ACL, where the keys are the prefixes and the values are the actions (ALLOW or BLOCK).
    manageEntries boolean
    Manage the ACL entries in Terraform (default: false). If true, Terraform will ensure that the ACL's entries match the entries in the Terraform configuration.
    compute_acl_id str
    Manages entries for a Fastly Compute Access Control List (ACL). To import, use the format \n\n/entries.
    entries Mapping[str, str]
    A map representing the entries in the Compute ACL, where the keys are the prefixes and the values are the actions (ALLOW or BLOCK).
    manage_entries bool
    Manage the ACL entries in Terraform (default: false). If true, Terraform will ensure that the ACL's entries match the entries in the Terraform configuration.
    computeAclId String
    Manages entries for a Fastly Compute Access Control List (ACL). To import, use the format \n\n/entries.
    entries Map<String>
    A map representing the entries in the Compute ACL, where the keys are the prefixes and the values are the actions (ALLOW or BLOCK).
    manageEntries Boolean
    Manage the ACL entries in Terraform (default: false). If true, Terraform will ensure that the ACL's entries match the entries in the Terraform configuration.

    Import

    Fastly Compute ACL entries can be imported using the format <compute_acl_id>/entries, e.g.

    $ pulumi import fastly:index/computeAclEntries:ComputeAclEntries example <compute_acl_id>/entries

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

    Package Details

    Repository
    Fastly pulumi/pulumi-fastly
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the fastly Terraform Provider.
    fastly logo
    Viewing docs for Fastly v11.4.1
    published on Friday, Feb 27, 2026 by Pulumi
    Schema (JSON)
    pulumi/pulumi-fastly
      Try Pulumi Cloud free. Your team will thank you.