Skip to main content
Astra Control Center

Install Astra Control Center using the standard process

Contributors netapp-dbagwell netapp-mwallis amgrissino Vaishnavi-Totewar netapp-rlithman wonderland
PDFs

To install Astra Control Center, download the installation images and perform the following steps. You can use this procedure to install Astra Control Center in internet-connected or air-gapped environments.

For a demonstration of the Astra Control Center installation process, see this video.

Before you begin

  • Ensure healthy services: Check that all API services are in a healthy state and available:

    kubectl get apiservices

  • Ensure a routable FQDN: The Astra FQDN you plan to use can be routed to the cluster. This means that you either have a DNS entry in your internal DNS server or you are using a core URL route that is already registered.

  • Configure cert manager: If a cert manager already exists in the cluster, you need to perform some prerequisite steps so that Astra Control Center does not attempt to install its own cert manager. By default, Astra Control Center installs its own cert manager during installation.

  • (ONTAP SAN driver only) Enable multipath: If you are using an ONTAP SAN driver, be sure that multipath is enabled on all your Kubernetes clusters.

You should also consider the following:

  • Get access to the NetApp Astra Control image registry:

    You have the option to obtain installation images and functionality enhancements for Astra Control, such as Astra Control Provisioner, from the NetApp image registry.

    1. Record your Astra Control account ID that you'll need to log in to the registry.

      You can see your account ID in the Astra Control Service web UI. Select the figure icon at the top right of the page, select API access, and write down your account ID.

    2. From the same page, select Generate API token and copy the API token string to the clipboard and save it in your editor.

    3. Log into the Astra Control registry:

      docker login cr.astra.netapp.io -u <account-id> -p <api-token>

  • Install a service mesh for secure communications: It is strongly recommended that Astra Control host cluster communications channels be secured using a supported service mesh.

    Important Integrating Astra Control Center with a service mesh can only be done during Astra Control Center installation and not independent of this process. Changing back from a meshed to an unmeshed environment is not supported.

    For Istio service mesh use, you'll need to do the following:

    • Add an istio-injection:enabled label to the Astra namespace prior to deploying Astra Control Center.

    • Use the Generic ingress setting and provide an alternative ingress for external load balancing.

    • For Red Hat OpenShift clusters, you need to define NetworkAttachmentDefinition on all associated Astra Control Center namespaces (netapp-acc-operator, netapp-acc, netapp-monitoring for application clusters, or any custom namespaces that have been substituted).

      cat <<EOF | oc -n netapp-acc-operator create -f -
apiVersion: "k8s.cni.cncf.io/v1"
kind: NetworkAttachmentDefinition
metadata:
  name: istio-cni
EOF

cat <<EOF | oc -n netapp-acc create -f -
apiVersion: "k8s.cni.cncf.io/v1"
kind: NetworkAttachmentDefinition
metadata:
  name: istio-cni
EOF

cat <<EOF | oc -n netapp-monitoring create -f -
apiVersion: "k8s.cni.cncf.io/v1"
kind: NetworkAttachmentDefinition
metadata:
  name: istio-cni
EOF
Steps

To install Astra Control Center, do the following steps:

Important Do not delete the Astra Control Center operator (for example, kubectl delete -f astra_control_center_operator_deploy.yaml) at any time during Astra Control Center installation or operation to avoid deleting pods.

Download and extract Astra Control Center

Download the Astra Control Center images from one of the following locations:

  • Astra Control Service image registry: Use this option if you don't use a local registry with the Astra Control Center images or if you prefer this method to the bundle download from the NetApp Support Site.

  • NetApp Support Site: Use this option if you use a local registry with the Astra Control Center images.

Astra Control image registry

  1. Log in to Astra Control Service.

  2. On the Dashboard, select Deploy a self-managed instance of Astra Control.

  3. Follow the instructions to log in to the Astra Control image registry, pull the Astra Control Center installation image, and extract the image.

NetApp Support Site

  1. Download the bundle containing Astra Control Center (astra-control-center-[version].tar.gz) from the Astra Control Center downloads page.

  2. (Recommended but optional) Download the certificates and signatures bundle for Astra Control Center (astra-control-center-certs-[version].tar.gz) to verify the signature of the bundle.

    tar -vxzf astra-control-center-certs-[version].tar.gz
    openssl dgst -sha256 -verify certs/AstraControlCenter-public.pub -signature certs/astra-control-center-[version].tar.gz.sig astra-control-center-[version].tar.gz

    The output will show Verified OK after successful verification.

  3. Extract the images from the Astra Control Center bundle:

    tar -vxzf astra-control-center-[version].tar.gz

Complete additional steps if you use a local registry

If you are planning to push the Astra Control Center bundle to your local registry, you need to use the NetApp Astra kubectl command line plugin.

Install the NetApp Astra kubectl plugin

Complete these steps to install the most recent NetApp Astra kubectl command line plugin.

Before you begin

NetApp provides plugin binaries for different CPU architectures and operating systems. You need to know which CPU and operating system you have before you perform this task.

If you already have the plugin installed from a previous installation, make sure you have the latest version before completing these steps.

Steps

  1. List the available NetApp Astra kubectl plugin binaries:

    Note The kubectl plugin library is part of the tar bundle and is extracted into the folder kubectl-astra. 
    ls kubectl-astra/

  2. Move the file you need for your operating system and CPU architecture into the current path and rename it to kubectl-astra:

    cp kubectl-astra/<binary-name> /usr/local/bin/kubectl-astra

Add the images to your registry

  1. If you are planning to push the Astra Control Center bundle to your local registry, complete the appropriate step sequence for your container engine:

    Docker

    1. Change to the root directory of the tarball. You should see the acc.manifest.bundle.yaml file and these directories:

      acc/
      kubectl-astra/
      acc.manifest.bundle.yaml

    2. Push the package images in the Astra Control Center image directory to your local registry. Make the following substitutions before running the push-images command:

      • Replace <BUNDLE_FILE> with the name of the Astra Control bundle file (acc.manifest.bundle.yaml).

      • Replace <MY_FULL_REGISTRY_PATH> with the URL of the Docker repository; for example, "https://<docker-registry>".

      • Replace <MY_REGISTRY_USER> with the user name.

      • Replace <MY_REGISTRY_TOKEN> with an authorized token for the registry.

        kubectl astra packages push-images -m <BUNDLE_FILE> -r <MY_FULL_REGISTRY_PATH> -u <MY_REGISTRY_USER> -p <MY_REGISTRY_TOKEN>
    Podman

    1. Change to the root directory of the tarball. You should see this file and directory:

      acc/
      kubectl-astra/
      acc.manifest.bundle.yaml

    2. Log in to your registry:

      podman login <YOUR_REGISTRY>

    3. Prepare and run one of the following scripts that is customized for the version of Podman you use. Substitute <MY_FULL_REGISTRY_PATH> with the URL of your repository that includes any sub-directories.

      Podman 4
      export REGISTRY=<MY_FULL_REGISTRY_PATH>
export PACKAGENAME=acc
export PACKAGEVERSION=24.02.0-69
export DIRECTORYNAME=acc
for astraImageFile in $(ls ${DIRECTORYNAME}/images/*.tar) ; do
astraImage=$(podman load --input ${astraImageFile} | sed 's/Loaded image: //')
astraImageNoPath=$(echo ${astraImage} | sed 's:.*/::')
podman tag ${astraImageNoPath} ${REGISTRY}/netapp/astra/${PACKAGENAME}/${PACKAGEVERSION}/${astraImageNoPath}
podman push ${REGISTRY}/netapp/astra/${PACKAGENAME}/${PACKAGEVERSION}/${astraImageNoPath}
done
      Podman 3
      export REGISTRY=<MY_FULL_REGISTRY_PATH>
export PACKAGENAME=acc
export PACKAGEVERSION=24.02.0-69
export DIRECTORYNAME=acc
for astraImageFile in $(ls ${DIRECTORYNAME}/images/*.tar) ; do
astraImage=$(podman load --input ${astraImageFile} | sed 's/Loaded image: //')
astraImageNoPath=$(echo ${astraImage} | sed 's:.*/::')
podman tag ${astraImageNoPath} ${REGISTRY}/netapp/astra/${PACKAGENAME}/${PACKAGEVERSION}/${astraImageNoPath}
podman push ${REGISTRY}/netapp/astra/${PACKAGENAME}/${PACKAGEVERSION}/${astraImageNoPath}
done
      Note The image path the script creates should resemble the following, depending on your registry configuration: 
      https://downloads.example.io/docker-astra-control-prod/netapp/astra/acc/24.02.0-69/image:version

  2. Change the directory:

    cd manifests

Set up namespace and secret for registries with auth requirements

  1. Export the kubeconfig for the Astra Control Center host cluster:

    export KUBECONFIG=[file path]
    Important Before you complete the installation, be sure your kubeconfig is pointing to the cluster where you want to install Astra Control Center.

  2. If you use a registry that requires authentication, you need to do the following:

    1. Create the netapp-acc-operator namespace:

      kubectl create ns netapp-acc-operator

    2. Create a secret for the netapp-acc-operator namespace. Add Docker information and run the following command:

      Note The placeholder your_registry_path should match the location of the images that you uploaded earlier (for example, [Registry_URL]/netapp/astra/astracc/24.02.0-69). 
      kubectl create secret docker-registry astra-registry-cred -n netapp-acc-operator --docker-server=cr.astra.netapp.io --docker-username=[astra_account_id] --docker-password=[astra_api_token]
      kubectl create secret docker-registry astra-registry-cred -n netapp-acc-operator --docker-server=[your_registry_path] --docker-username=[username] --docker-password=[token]
      Note If you delete the namespace after the secret is generated, recreate the namespace and then regenerate the secret for the namespace.

    3. Create the netapp-acc (or custom-named) namespace.

      kubectl create ns [netapp-acc or custom namespace]

    4. Create a secret for the netapp-acc (or custom-named) namespace. Add Docker information and run one of the the appropriate command depending on your registry preference:

      kubectl create secret docker-registry astra-registry-cred -n [netapp-acc or custom namespace] --docker-server=cr.astra.netapp.io --docker-username=[astra_account_id] --docker-password=[astra_api_token]
      kubectl create secret docker-registry astra-registry-cred -n [netapp-acc or custom namespace] --docker-server=[your_registry_path] --docker-username=[username] --docker-password=[token]

Install the Astra Control Center operator

  1. (Local registries only) If you are using a local registry, complete these steps:

    1. Open the Astra Control Center operator deployment YAML:

      vim astra_control_center_operator_deploy.yaml
      Note An annotated sample YAML follows these steps.

    2. If you use a registry that requires authentication, replace the default line of imagePullSecrets: [] with the following:

      imagePullSecrets: [{name: astra-registry-cred}]

    3. Change ASTRA_IMAGE_REGISTRY for the kube-rbac-proxy image to the registry path where you pushed the images in a previous step.

    4. Change ASTRA_IMAGE_REGISTRY for the acc-operator-controller-manager image to the registry path where you pushed the images in a previous step.

    apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    control-plane: controller-manager
  name: acc-operator-controller-manager
  namespace: netapp-acc-operator
spec:
  replicas: 1
  selector:
    matchLabels:
      control-plane: controller-manager
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        control-plane: controller-manager
    spec:
      containers:
      - args:
        - --secure-listen-address=0.0.0.0:8443
        - --upstream=http://127.0.0.1:8080/
        - --logtostderr=true
        - --v=10
        image: ASTRA_IMAGE_REGISTRY/kube-rbac-proxy:v4.8.0
        name: kube-rbac-proxy
        ports:
        - containerPort: 8443
          name: https
      - args:
        - --health-probe-bind-address=:8081
        - --metrics-bind-address=127.0.0.1:8080
        - --leader-elect
        env:
        - name: ACCOP_LOG_LEVEL
          value: "2"
        - name: ACCOP_HELM_INSTALLTIMEOUT
          value: 5m
        image: ASTRA_IMAGE_REGISTRY/acc-operator:24.02.68
        imagePullPolicy: IfNotPresent
        livenessProbe:
          httpGet:
            path: /healthz
            port: 8081
          initialDelaySeconds: 15
          periodSeconds: 20
        name: manager
        readinessProbe:
          httpGet:
            path: /readyz
            port: 8081
          initialDelaySeconds: 5
          periodSeconds: 10
        resources:
          limits:
            cpu: 300m
            memory: 750Mi
          requests:
            cpu: 100m
            memory: 75Mi
        securityContext:
          allowPrivilegeEscalation: false
      imagePullSecrets: []
      securityContext:
        runAsUser: 65532
      terminationGracePeriodSeconds: 10

  2. Install the Astra Control Center operator:

    kubectl apply -f astra_control_center_operator_deploy.yaml
    Expand for sample response: 
    namespace/netapp-acc-operator created
customresourcedefinition.apiextensions.k8s.io/astracontrolcenters.astra.netapp.io created
role.rbac.authorization.k8s.io/acc-operator-leader-election-role created
clusterrole.rbac.authorization.k8s.io/acc-operator-manager-role created
clusterrole.rbac.authorization.k8s.io/acc-operator-metrics-reader created
clusterrole.rbac.authorization.k8s.io/acc-operator-proxy-role created
rolebinding.rbac.authorization.k8s.io/acc-operator-leader-election-rolebinding created
clusterrolebinding.rbac.authorization.k8s.io/acc-operator-manager-rolebinding created
clusterrolebinding.rbac.authorization.k8s.io/acc-operator-proxy-rolebinding created
configmap/acc-operator-manager-config created
service/acc-operator-controller-manager-metrics-service created
deployment.apps/acc-operator-controller-manager created

  3. Verify pods are running:

    kubectl get pods -n netapp-acc-operator

Configure Astra Control Center

  1. Edit the Astra Control Center custom resource (CR) file (astra_control_center.yaml) to make account, support, registry, and other necessary configurations:

    vim astra_control_center.yaml
    Note An annotated sample YAML follows these steps.

  2. Modify or confirm the following settings:

    accountName
    Setting Guidance Type Example

    accountName

    Change the accountName string to the name you want to associate with the Astra Control Center account. There can be only one accountName.

    string

    Example
    astraVersion
    Setting Guidance Type Example

    astraVersion

    The version of Astra Control Center to deploy. No action is needed for this setting as the value will be pre-populated.

    string

    24.02.0-69
    astraAddress
    Setting Guidance Type Example

    astraAddress

    Change the astraAddress string to the FQDN (recommended) or IP address you want to use in your browser to access Astra Control Center. This address defines how Astra Control Center will be found in your data center and is the same FQDN or IP address you provisioned from your load balancer when you completed Astra Control Center requirements.

    NOTE: Do not use http:// or https:// in the address. Copy this FQDN for use in a later step.

    string

    astra.example.com
    autoSupport

    Your selections in this section determine whether you'll participate in NetApp's pro-active support application, Digital Advisor, and where data is sent. An internet connection is required (port 442), and all support data is anonymized.

    Setting Use Guidance Type Example

    autoSupport.enrolled

    Either enrolled or url fields must be selected

    Change enrolled for AutoSupport to false for sites without internet connectivity or retain true for connected sites. A setting of true enables anonymous data to be sent to NetApp for support purposes. The default election is false and indicates no support data will be sent to NetApp.

    Boolean

    false (this value is the default)

    autoSupport.url

    Either enrolled or url fields must be selected

    This URL determines where the anonymous data will be sent.

    string

    https://support.netapp.com/asupprod/post/1.0/postAsup
    email
    Setting Guidance Type Example

    email

    Change the email string to the default initial administrator address. Copy this email address for use in a later step. This email address will be used as the username for the initial account to log in to the UI and will be notified of events in Astra Control.

    string

    admin@example.com
    firstName
    Setting Guidance Type Example

    firstName

    The first name of the default initial administrator associated with the Astra account. The name used here will be visible in a heading in the UI after your first login.

    string

    SRE
    LastName
    Setting Guidance Type Example

    lastName

    The last name of the default initial administrator associated with the Astra account. The name used here will be visible in a heading in the UI after your first login.

    string

    Admin
    imageRegistry

    Your selections in this section define the container image registry that is hosting the Astra application images, Astra Control Center Operator, and Astra Control Center Helm repository.

    Setting Use Guidance Type Example

    imageRegistry.name

    Required

    The name of the Astra Control image registry that hosts all images required to deploy Astra Control Center. The value will be pre-populated, and no action is required unless you configured a local registry. For a local registry, replace this existing value with the name of the image registry where you pushed the images in the previous step. Do not use http:// or https:// in the registry name.

    string

    cr.astra.netapp.io (default)
    example.registry.com/astra (local registry example)

    imageRegistry.secret

    Optional

    The name of the Kubernetes secret used to authenticate with the image registry. The value will be pre-populated, and no action is required unless you configured a local registry and the string you entered for that registry in imageRegistry.name requires a secret.

    IMPORTANT: If you are using a local registry that does not require authorization, you must delete this secret line within imageRegistry or the installation will fail.

    string

    astra-registry-cred
    storageClass
    Setting Guidance Type Example

    storageClass

    Change the storageClass value from ontap-gold to another storageClass resource as required by your installation. Run the command kubectl get sc to determine your existing configured storage classes. One of the Astra Control Provisioner-configured storage classes must be entered in the manifest file (astra-control-center-<version>.manifest) and will be used for Astra PVs. If it is not set, the default storage class will be used.

    NOTE: If a default storage class is configured, ensure that it is the only storage class that has the default annotation.

    string

    ontap-gold
    volumeReclaimPolicy
    Setting Guidance Type Options

    volumeReclaimPolicy

    This sets the reclaim policy for Astra's PVs. Setting this policy to Retain retains persistent volumes after Astra is deleted. Setting this policy to Delete deletes persistent volumes after astra is deleted. If this value is not set, the PVs are retained.

    string

    • Retain (This is the default value)

    • Delete
    ingressType
    Setting Guidance Type Options

    ingressType

    Use one of the following ingress types:

    Generic (ingressType: "Generic") (Default)
    Use this option when you have another ingress controller in use or would prefer to use your own ingress controller. After Astra Control Center is deployed, you'll need to configure the ingress controller to expose Astra Control Center with a URL.

    IMPORTANT: If you intend to use a service mesh with Astra Control Center, you must select Generic as ingress type and set up your own ingress controller.


    AccTraefik (ingressType: "AccTraefik")
    Use this option when you would prefer not to configure an ingress controller. This deploys the Astra Control Center traefik gateway as a Kubernetes LoadBalancer type service.

    Astra Control Center uses a service of the type "LoadBalancer" (svc/traefik in the Astra Control Center namespace), and requires that it be assigned an accessible external IP address. If load balancers are permitted in your environment and you don't already have one configured, you can use MetalLB or another external service load balancer to assign an external IP address to the service. In the internal DNS server configuration, you should point the chosen DNS name for Astra Control Center to the load-balanced IP address.

    NOTE: For details about the service type of "LoadBalancer" and ingress, refer to Requirements.

    string

    • Generic (this is the default value)

    • AccTraefik
    scaleSize
    Setting Guidance Type Options

    scaleSize

    By default, Astra will use High Availability (HA) scaleSize of Medium, which deploys most services in HA and deploys multiple replicas for redundancy. With scaleSize as Small, Astra will reduce the number of replicas for all services except for essential services to reduce consumption.

    TIP: Medium deployments consist of around 100 pods (not including transient workloads. 100 pods is based on a three master node and three worker node configuration). Be aware of per-pod network limit constraints that might be an issue in your environment, especially when considering disaster recovery scenarios.

    string

    • Small

    • Medium (This is the default value)
    astraResourcesScaler
    Setting Guidance Type Options

    astraResourcesScaler

    Scaling options for AstraControlCenter Resource limits. By default, Astra Control Center deploys with resource requests set for most of the components within Astra. This configuration allows the Astra Control Center software stack to perform better in environments under increased application load and scale.

    However, in scenarios using smaller development or test clusters, the CR field astraResourcesScalar may be set to Off. This disables resource requests and allows for deployment on smaller clusters.

    string

    • Default (This is the default value)

    • Off
    additionalValues
    Important Add the following additional values to the Astra Control Center CR to prevent a known issue in installation: 
    additionalValues:
    keycloak-operator:
      livenessProbe:
        initialDelaySeconds: 180
      readinessProbe:
        initialDelaySeconds: 180
    crds

    Your selections in this section determine how Astra Control Center should handle CRDs.

    Setting Guidance Type Example

    crds.externalCertManager

    If you use an external cert manager, change externalCertManager to true. The default false causes Astra Control Center to install its own cert manager CRDs during installation.

    CRDs are cluster-wide objects and installing them might have an impact on other parts of the cluster. You can use this flag to signal to Astra Control Center that these CRDs will be installed and managed by the cluster administrator outside of Astra Control Center.

    Boolean

    False (this value is the default)

    crds.externalTraefik

    By default, Astra Control Center will install required Traefik CRDs. CRDs are cluster-wide objects and installing them might have an impact on other parts of the cluster. You can use this flag to signal to Astra Control Center that these CRDs will be installed and managed by the cluster administrator outside of Astra Control Center.

    Boolean

    False (this value is the default)
Important Be sure that you have selected the correct storage class and ingress type for your configuration before completing installation.
sample astra_control_center.yaml
apiVersion: astra.netapp.io/v1
kind: AstraControlCenter
metadata:
  name: astra
spec:
  accountName: "Example"
  astraVersion: "ASTRA_VERSION"
  astraAddress: "astra.example.com"
  autoSupport:
    enrolled: true
  email: "[admin@example.com]"
  firstName: "SRE"
  lastName: "Admin"
  imageRegistry:
    name: "[cr.astra.netapp.io or your_registry_path]"
    secret: "astra-registry-cred"
  storageClass: "ontap-gold"
  volumeReclaimPolicy: "Retain"
  ingressType: "Generic"
  scaleSize: "Medium"
  astraResourcesScaler: "Default"
  additionalValues:
    keycloak-operator:
      livenessProbe:
        initialDelaySeconds: 180
      readinessProbe:
        initialDelaySeconds: 180
  crds:
    externalTraefik: false
    externalCertManager: false

Complete Astra Control Center and operator installation

  1. If you didn't already do so in a previous step, create the netapp-acc (or custom) namespace:

    kubectl create ns [netapp-acc or custom namespace]

  2. If you are using a service mesh with Astra Control Center, add the following label to the netapp-acc or custom namespace:

    Important Your ingress type (ingressType) must be set to Generic in the Astra Control Center CR before proceeding with this command. 
    kubectl label ns [netapp-acc or custom namespace] istio-injection:enabled

  3. (Recommended) Enable strict MTLs for Istio service mesh:

    kubectl apply -n istio-system -f - <<EOF
apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
  name: default
spec:
  mtls:
    mode: STRICT
EOF

  4. Install Astra Control Center in the netapp-acc (or your custom) namespace:

    kubectl apply -f astra_control_center.yaml -n [netapp-acc or custom namespace]
Important The Astra Control Center operator will run an automatic check for environment requirements. Missing requirements can cause your installation to fail or Astra Control Center to not operate properly. See the next section to check for warning messages related to the automatic system check.

Verify system status

You can verify system status using kubectl commands. If you prefer to use OpenShift, you can use comparable oc commands for verification steps.

Steps

  1. Verify that the installation process did not produce warnings messages related to the validation checks:

    kubectl get acc [astra or custom Astra Control Center CR name] -n [netapp-acc or custom namespace] -o yaml
    Note Additional warning messages are also reported in the Astra Control Center operator logs.

  2. Correct any issues with your environment that were reported by the automated requirements checks.

    Note You can correct issues by ensuring that your environment meets the requirements for Astra Control Center.

  3. Verify that all system components installed successfully.

    kubectl get pods -n [netapp-acc or custom namespace]

    Each pod should have a status of Running. It may take several minutes before the system pods are deployed.

    Expand for sample response 
    acc-helm-repo-5bd77c9ddd-8wxm2             1/1     Running     0               1h
activity-5bb474dc67-8l9ss                  1/1     Running     0               1h
activity-5bb474dc67-qbrtq                  1/1     Running     0               1h
api-token-authentication-6wbj2             1/1     Running     0               1h
api-token-authentication-9pgw6             1/1     Running     0               1h
api-token-authentication-tqf6d             1/1     Running     0               1h
asup-5495f44dbd-z4kft                      1/1     Running     0               1h
authentication-6fdd899858-5x45s            1/1     Running     0               1h
bucketservice-84d47487d-n9xgp              1/1     Running     0               1h
bucketservice-84d47487d-t5jhm              1/1     Running     0               1h
cert-manager-5dcb7648c4-hbldc              1/1     Running     0               1h
cert-manager-5dcb7648c4-nr9qf              1/1     Running     0               1h
cert-manager-cainjector-59b666fb75-bk2tf   1/1     Running     0               1h
cert-manager-cainjector-59b666fb75-pfnck   1/1     Running     0               1h
cert-manager-webhook-c6f9b6796-ngz2x       1/1     Running     0               1h
cert-manager-webhook-c6f9b6796-rwtbn       1/1     Running     0               1h
certificates-5f5b7b4dd-52tnj               1/1     Running     0               1h
certificates-5f5b7b4dd-gtjbx               1/1     Running     0               1h
certificates-expiry-check-28477260-dz5vw   0/1     Completed   0               1h
cloud-extension-6f58cc579c-lzfmv           1/1     Running     0               1h
cloud-extension-6f58cc579c-zw2km           1/1     Running     0               1h
cluster-orchestrator-79dd5c8d95-qjg92      1/1     Running     0               1h
composite-compute-85dc84579c-nz82f         1/1     Running     0               1h
composite-compute-85dc84579c-wx2z2         1/1     Running     0               1h
composite-volume-bff6f4f76-789nj           1/1     Running     0               1h
composite-volume-bff6f4f76-kwnd4           1/1     Running     0               1h
credentials-79fd64f788-m7m8f               1/1     Running     0               1h
credentials-79fd64f788-qnc6c               1/1     Running     0               1h
entitlement-f69cdbd77-4p2kn                1/1     Running     0               1h
entitlement-f69cdbd77-hswm6                1/1     Running     0               1h
features-7b9585444c-7xd7m                  1/1     Running     0               1h
features-7b9585444c-dcqwc                  1/1     Running     0               1h
fluent-bit-ds-crq8m                        1/1     Running     0               1h
fluent-bit-ds-gmgq8                        1/1     Running     0               1h
fluent-bit-ds-gzr4f                        1/1     Running     0               1h
fluent-bit-ds-j6sf6                        1/1     Running     0               1h
fluent-bit-ds-v4t9f                        1/1     Running     0               1h
fluent-bit-ds-x7j59                        1/1     Running     0               1h
graphql-server-6cc684fb46-2x8lr            1/1     Running     0               1h
graphql-server-6cc684fb46-bshbd            1/1     Running     0               1h
hybridauth-84599f79fd-fjc7k                1/1     Running     0               1h
hybridauth-84599f79fd-s9pmn                1/1     Running     0               1h
identity-95df98cb5-dvlmz                   1/1     Running     0               1h
identity-95df98cb5-krf59                   1/1     Running     0               1h
influxdb2-0                                1/1     Running     0               1h
keycloak-operator-6d4d688697-cfq8b         1/1     Running     0               1h
krakend-5d5c8f4668-7bq8g                   1/1     Running     0               1h
krakend-5d5c8f4668-t8hbn                   1/1     Running     0               1h
license-689cdd4595-2gsc8                   1/1     Running     0               1h
license-689cdd4595-g6vwk                   1/1     Running     0               1h
login-ui-57bb599956-4fwgz                  1/1     Running     0               1h
login-ui-57bb599956-rhztb                  1/1     Running     0               1h
loki-0                                     1/1     Running     0               1h
metrics-facade-846999bdd4-f7jdm            1/1     Running     0               1h
metrics-facade-846999bdd4-lnsxl            1/1     Running     0               1h
monitoring-operator-6c9d6c4b8c-ggkrl       2/2     Running     0               1h
nats-0                                     1/1     Running     0               1h
nats-1                                     1/1     Running     0               1h
nats-2                                     1/1     Running     0               1h
natssync-server-6df7d6cc68-9v2gd           1/1     Running     0               1h
nautilus-64b7fbdd98-bsgwb                  1/1     Running     0               1h
nautilus-64b7fbdd98-djlhw                  1/1     Running     0               1h
openapi-864584bccc-75nlv                   1/1     Running     0               1h
openapi-864584bccc-zh6bx                   1/1     Running     0               1h
polaris-consul-consul-server-0             1/1     Running     0               1h
polaris-consul-consul-server-1             1/1     Running     0               1h
polaris-consul-consul-server-2             1/1     Running     0               1h
polaris-keycloak-0                         1/1     Running     2 (1h ago)      1h
polaris-keycloak-1                         1/1     Running     0               1h
polaris-keycloak-db-0                      1/1     Running     0               1h
polaris-keycloak-db-1                      1/1     Running     0               1h
polaris-keycloak-db-2                      1/1     Running     0               1h
polaris-mongodb-0                          1/1     Running     0               1h
polaris-mongodb-1                          1/1     Running     0               1h
polaris-mongodb-2                          1/1     Running     0               1h
polaris-ui-66476dcf87-f6s8j                1/1     Running     0               1h
polaris-ui-66476dcf87-ztjk7                1/1     Running     0               1h
polaris-vault-0                            1/1     Running     0               1h
polaris-vault-1                            1/1     Running     0               1h
polaris-vault-2                            1/1     Running     0               1h
public-metrics-bfc4fc964-x4m79             1/1     Running     0               1h
storage-backend-metrics-7dbb88d4bc-g78cj   1/1     Running     0               1h
storage-provider-5969b5df5-hjvcm           1/1     Running     0               1h
storage-provider-5969b5df5-r79ld           1/1     Running     0               1h
task-service-5fc9dc8d99-4q4f4              1/1     Running     0               1h
task-service-5fc9dc8d99-8l5zl              1/1     Running     0               1h
task-service-task-purge-28485735-fdzkd     1/1     Running     0               12m
telegraf-ds-2rgm4                          1/1     Running     0               1h
telegraf-ds-4qp6r                          1/1     Running     0               1h
telegraf-ds-77frs                          1/1     Running     0               1h
telegraf-ds-bc725                          1/1     Running     0               1h
telegraf-ds-cvmxf                          1/1     Running     0               1h
telegraf-ds-tqzgj                          1/1     Running     0               1h
telegraf-rs-5wtd8                          1/1     Running     0               1h
telemetry-service-6747866474-5djnc         1/1     Running     0               1h
telemetry-service-6747866474-thb7r         1/1     Running     1 (1h ago)      1h
tenancy-5669854fb6-gzdzf                   1/1     Running     0               1h
tenancy-5669854fb6-xvsm2                   1/1     Running     0               1h
traefik-8f55f7d5d-4lgfw                    1/1     Running     0               1h
traefik-8f55f7d5d-j4wt6                    1/1     Running     0               1h
traefik-8f55f7d5d-p6gcq                    1/1     Running     0               1h
trident-svc-7cb5bb4685-54cnq               1/1     Running     0               1h
trident-svc-7cb5bb4685-b28xh               1/1     Running     0               1h
vault-controller-777b9bbf88-b5bqt          1/1     Running     0               1h
vault-controller-777b9bbf88-fdfd8          1/1     Running     0               1h

  4. (Optional) Watch the acc-operator logs to monitor progress:

    kubectl logs deploy/acc-operator-controller-manager -n netapp-acc-operator -c manager -f
    Note accHost cluster registration is one of the last operations, and if it fails it will not cause deployment to fail. In the event of a cluster registration failure indicated in the logs, you can attempt registration again through the Add cluster workflow in the UI or API.

  5. When all the pods are running, verify that the installation was successful (READY is True) and get the initial setup password you'll use when you log in to Astra Control Center:

    kubectl get AstraControlCenter -n [netapp-acc or custom namespace]

    Response:

    NAME    UUID                                  VERSION     ADDRESS         READY
astra   9aa5fdae-4214-4cb7-9976-5d8b4c0ce27f  24.02.0-69   10.111.111.111  True
    Important Copy the UUID value. The password is ACC- followed by the UUID value (ACC-[UUID] or, in this example, ACC-9aa5fdae-4214-4cb7-9976-5d8b4c0ce27f).

Set up ingress for load balancing

You can set up a Kubernetes ingress controller that manages external access to services. These procedures give setup examples for an ingress controller if you used the default of ingressType: "Generic" in the Astra Control Center custom resource (astra_control_center.yaml). You do not need to use this procedure if you specified ingressType: "AccTraefik" in the Astra Control Center custom resource (astra_control_center.yaml).

After Astra Control Center is deployed, you'll need to configure the ingress controller to expose Astra Control Center with a URL.

Setup steps differ depending on the type of ingress controller you use. Astra Control Center supports many ingress controller types. These setup procedures provide example steps for some common ingress controller types.

Before you begin

Steps for Istio ingress

  1. Configure Istio ingress.

    Note This procedure assumes that Istio is deployed using the "default" configuration profile.

  2. Gather or create the desired certificate and private key file for the Ingress Gateway.

    You can use a CA-signed or self-signed certificate. The common name must be the Astra address (FQDN).

    Sample command:

    openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout tls.key -out tls.crt

  3. Create a secret tls secret name of type kubernetes.io/tls for a TLS private key and certificate in the istio-system namespace as described in TLS secrets.

    Sample command:

    kubectl create secret tls [tls secret name] --key="tls.key" --cert="tls.crt" -n istio-system
    Tip The name of the secret should match the spec.tls.secretName provided in istio-ingress.yaml file.

  4. Deploy an ingress resource in the netapp-acc (or custom-named) namespace using the v1 resource type for a schema (istio-Ingress.yaml is used in this example):

    apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
  name: istio
spec:
  controller: istio.io/ingress-controller
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: ingress
  namespace: [netapp-acc or custom namespace]
spec:
  ingressClassName: istio
  tls:
  - hosts:
    - <ACC address>
    secretName: [tls secret name]
  rules:
  - host: [ACC address]
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: traefik
            port:
              number: 80

  5. Apply the changes:

    kubectl apply -f istio-Ingress.yaml

  6. Check the status of the ingress:

    kubectl get ingress -n [netapp-acc or custom namespace]

    Response:

    NAME    CLASS HOSTS             ADDRESS         PORTS   AGE
ingress istio astra.example.com 172.16.103.248  80, 443 1h

  7. Finish Astra Control Center installation.

Steps for Nginx ingress controller

  1. Create a secret of type kubernetes.io/tls for a TLS private key and certificate in netapp-acc (or custom-named) namespace as described in TLS secrets.

  2. Deploy an ingress resource in netapp-acc (or custom-named) namespace using the v1 resource type for a schema (nginx-Ingress.yaml is used in this example):

    apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: netapp-acc-ingress
  namespace: [netapp-acc or custom namespace]
spec:
  ingressClassName: [class name for nginx controller]
  tls:
  - hosts:
    - <ACC address>
    secretName: [tls secret name]
  rules:
  - host: <ACC address>
    http:
      paths:
        - path:
          backend:
            service:
              name: traefik
              port:
                number: 80
          pathType: ImplementationSpecific

  3. Apply the changes:

    kubectl apply -f nginx-Ingress.yaml
Warning NetApp recommends installing the nginx controller as a deployment rather than a daemonSet.

Steps for OpenShift ingress controller

  1. Procure your certificate and get the key, certificate, and CA files ready for use by the OpenShift route.

  2. Create the OpenShift route:

    oc create route edge --service=traefik --port=web -n [netapp-acc or custom namespace] --insecure-policy=Redirect --hostname=<ACC address> --cert=cert.pem --key=key.pem

Log in to the Astra Control Center UI

After installing Astra Control Center, you'll change the password for the default administrator and log in to the Astra Control Center UI dashboard.

Steps

  1. In a browser, enter the FQDN (including the https:// prefix) you used in the astraAddress in the astra_control_center.yaml CR when you installed Astra Control Center.

  2. Accept the self-signed certificates if prompted.

    Note You can create a custom certificate after login.

  3. At the Astra Control Center login page, enter the value you used for email in astra_control_center.yaml CR when you installed Astra Control Center, followed by the initial setup password (ACC-[UUID]).

    Note If you enter an incorrect password three times, the admin account will be locked for 15 minutes.

  4. Select Login.

  5. Change the password when prompted.

    Note If this is your first login and you forget the password and no other administrative user accounts have yet been created, contact NetApp Support for password recovery assistance.

  6. (Optional) Remove the existing self-signed TLS certificate and replace it with a custom TLS certificate signed by a Certificate Authority (CA).

Troubleshoot the installation

If any of the services are in Error status, you can inspect the logs. Look for API response codes in the 400 to 500 range. Those indicate the place where a failure happened.

Options

  • To inspect the Astra Control Center operator logs, enter the following:

    kubectl logs deploy/acc-operator-controller-manager -n netapp-acc-operator -c manager -f

  • To check the output of the Astra Control Center CR:

    kubectl get acc -n [netapp-acc or custom namespace] -o yaml

Alternative installation procedures

  • Install with Red Hat OpenShift OperatorHub: Use this alternative procedure to install Astra Control Center on OpenShift using OperatorHub.

  • Install in the public cloud with Cloud Volumes ONTAP backend: Use these procedures to install Astra Control Center in Amazon Web Services (AWS), Google Cloud Platform (GCP), or Microsoft Azure with a Cloud Volumes ONTAP storage backend.

What's next