Content Platform System Management Help

Version: 9.4.x
Audience: anonymous
Part Number: MK-95HCPH001-17

Administering HCP
Introduction to Hitachi Content Platform
About the Hitachi Content Platform
Object-based storage
Namespaces and tenants
Data access methods
Namespace access protocols
HCP Namespace Browser
HCP metadata query API
HCP Search Console
Object representation
HCP nodes and storage
General nodes
Linear scalability
HCP architecture
Repository management
Data integrity and security
Data availability
Regulatory compliance
Storage usage optimization
Network bandwidth usage optimization
HCP administration
System Management Console
System Management Console URL
Logging in
Using the System Management Console
Refreshing pages
Submitting changes
Changing your password
Logging out
HCP administrative responsibilities
Account administration
About user and group accounts
Roles and permissions
Available roles
Tenant-level administration
Permissions granted by role
User authentication
Starter account
Working with user accounts
About the Users page
Understanding the user account list
Managing the user account list
Paging
Sorting
Filtering
Creating a user account
Modifying a user account
Deleting a user account
Generating a user authorization token
Working with group accounts
Groups page
Paging
Sorting
Filtering
Creating group accounts
Modifying a group account
Deleting a group account
Changing user account and login settings
Login settings
Login message
System-level administration
About the Overview page
Alerts
Current service status
Major events
System graphs
Storage graphs
Considerations for monitoring your HCP system
Configuring the system time
Shutting down or restarting HCP
Shutting down HCP
Restarting HCP
Hardware administration
About the Hardware page
About the Nodes page
Monitoring individual HCP general nodes
Monitoring individual HCP S Series Nodes
Modifying HCP S Series Nodes
About the Switches page
Adding a switch
About the Chassis tab
About the individual HCP G Series Node pages
Hardware status
Logical volume usage details
Core hardware details
File systems on storage devices managed by a node
IPMI information
Network interface cards (NICs)
File system status
Node events
Shutting down or restarting individual nodes
Shutting down an individual node
Restarting an individual node
Storage administration
Storage for HCP systems
About storage components
Primary storage components
HCP S Series storage components
Extended storage components
About storage pools
Primary storage pools
HCP S Series storage pools
Extended storage pools
Storing objects on extended storage tiers
Considerations for tiering objects from primary storage to HCP S Series or extended storage
Encryption and compression of objects in storage pools
Downloading an encryption key
Uploading an encryption key
Working with HCP S Series storage components
Add an S Series Node to your HCP system
Creating an HCP S Series storage component
Modifying an HCP S Series storage component
Modifying basic component settings
Modifying advanced component settings
Pausing and resuming an HCP S Series storage component
Deleting an HCP S Series storage component
Abandoning an HCP S Series storage component
Working with buckets and accounts on an HCP S Series storage component
Creating a bucket
Deleting a bucket
Adding an existing bucket to an HCP S Series storage component
Adding an existing S Series Node user account
Updating the owner of a bucket
Deleting an S Series Node user account
Working with extended storage components
Creating an extended storage component
Amazon S3 storage component settings
Google Cloud storage component settings
Microsoft Azure storage component settings
S3 compatible storage component settings
NFS storage component settings
Creating NFS shares on a physical storage device
Exports and required NFS component settings
Modifying an extended storage component
Modifying the configuration settings that are specified for an extended storage component
Modifying the advanced configuration settings that are used for an extended storage component
Adding access points to an extended storage component
Configuring a new user account for access to an extended storage endpoint
Updating the owner of a bucket in an extended storage component
Deleting an unused access point from an extended storage component
Deleting an unused user account from an extended storage component
Uploading an account certificate for CAP authentication
Pausing and resuming an extended storage component
Deleting or abandoning an extended storage component
Deleting an unused extended storage component
Abandoning an extended storage component
Working with HCP S Series storage pools
Creating an HCP S Series storage pool
Modifying an HCP S Series storage pool
Modifying the settings of an HCP S Series storage pool
Adding buckets to an HCP S Series storage pool
Deleting buckets from an HCP S Series storage pool
Deleting an HCP S Series storage pool
Working with extended storage pools
Creating an extended storage pool
Amazon S3 and S3 compatible storage pools
Google Cloud storage pools
Microsoft Azure storage pools
NFS storage pools
Manually remount the NFS volume
Considerations for using NFS volumes (cont)
Reusing the exported share
Manually remounting the NFS volume
Considerations for using NFS volumes (last part)
Modifying an extended storage pool
Modifying the configuration settings used for an extended storage pool
Adding access points to an extended storage pool
Deleting access points from an extended storage pool
Remounting an NFS volume
Deleting an extended storage pool
Retiring storage
Retiring primary storage devices
Before starting a primary storage retirement
Using the Retire Primary Storage wizard to perform a data migration
Retiring S Series and extended storage pools, components, and volumes
About service plans
Storage tiers
Storage tier properties specified in service plans
How HCP uses the information in service plans
Metadata-only storage tiers
Rehydration
Default service plan configuration settings
General considerations for namespace service plans
Object content stored on different types of storage
Storage allocation for objects on an HCP S Series or extended storage tier
Service plans and read requests
Service plans for tenants and namespaces
Service plans and replication
Working with service plans
Creating a service plan
Modifying a service plan
Modifying basic configuration settings for a service plan
Adding a storage tier to a service plan
Removing one or more storage tiers from a service plan
Choose the ingest tier
Selecting primary running storage as the ingest tier
Selecting HCP S Series storage pools as your ingest tier
Assigning a service plan to one or more tenants
Retiring a service plan
Deleting a service plan
Monitoring storage
About the storage Overview page
Understanding the storage component list
Understanding component and pool details for primary storage
Understanding component details for HCP S Series and extended storage
HCP S Series and extended storage component reads and writes
Bucket, container, or mount point list for HCP S Series and extended storage components
Account list
Understanding the storage pool list
Understanding pool details for HCP S Series and extended storage
HCP S Series and extended storage pool reads and writes
Bucket, container, or mount point list for HCP S Series and extended storage pools
Understanding the service plan list
Understanding service plan usage details
About storage reports
Generating a storage report
Storage report content
Sample storage report
Network administration
HCP networks
IP modes
About virtual networking with HCP
Front-end network usage
Network properties
Tagged and untagged networks
Network domains
Downstream DNS configuration settings for networks
Advanced downstream DNS configuration
Network aliases
Network states
Isolating networks for storage tiering
Considerations for virtual networking
About the Networks page
About the Network View page
Understanding the network list
Managing the network list
Paging
Sorting
Filtering the list by network name
Filtering the list by IP mode
About the Node View page
Understanding the node list
Managing the node list
Paging
Sorting the node list
Filtering the list by node number
Filtering the list by node status
About the All Zone Definitions pages
About the Advanced Setting panel
Enabling IPv4 and IPv6 addresses
Enabling and configuring the management network
Creating a network
Assigning IP addresses to nodes for a network
Using the Network View page to configure node IP addresses for a network
Using the Node View page to assign network IP addresses to a node
Changing the default downstream DNS configuration settings for a network
Changing the advanced downstream DNS configuration settings for a network
Creating a network alias
Viewing and modifying properties of a network or network alias
Viewing properties of a network or network alias on the Network View page
Network and network alias properties displayed on the Settings panel
Network and network alias properties displayed on the IP Configuration panel
Network and network alias properties displayed on the Zone Definitions panel
Viewing properties of a network on the Node View page
Viewing the DNS zone definition for a network domain
Viewing the DNS zone definition for a specific network
Viewing the DNS zone definitions for all existing networks
Considerations for modifying properties of networks and network aliases
Modifying a network
Modifying a network on the Network View panel
Modifying network IP address assignments for a node on the Node View page
Modifying a network alias
Restarting a network
Deleting a network or network alias
Tenant administration
About the Tenants page
Understanding the tenant list
Managing the tenant list
Paging
Sorting
Filtering
Filter the tenant list by tag using the tag control
About the tenant Overview panel
Tenant URL
Tenant description
Features Enabled section
Namespaces section
Objects section
Storage section
Creating a tenant
Creating an HCP tenant
HCP tenant properties
HCP tenant creation procedure
Creating the default tenant and namespace
Default tenant and namespace properties
Default tenant and namespace creation procedure
Accessing the Tenant Management Console for a tenant
Modifying a tenant
Modifying tenant properties
Tenant-level CORS rules configuration
Request elements (CORS rules)
CORS configuration template
Configuring CORS rules at the tenant-level
Protocol optimization
Setting the default protocol optimization option and directory usage for new namespaces
Cloud-optimizing existing namespaces
Resetting HCP tenant security
Resetting security for an HCP tenant
Deleting a tenant
Changing the product branding
Changing the product name and abbreviation
Changing the company logo
Resetting the branding
Search administration
Configuring search
Metadata query engine
About the metadata query engine
Metadata query engine index
Metadata query engine management
Configuring the metadata query engine
Deleting the metadata query engine index
Search facility status
Search facility availability
Metadata query engine indexing status
Enabling or disabling the Search Console
HCP policies
Retention policy
Shredding policy
Indexing policy
Versioning policy
Custom metadata XML checking policy
HCP services
About services
Service types
Service precedence
Metadata storage
Service scheduling
How scheduled services work
About the Services Schedule page
Services legend
Schedule grid
Service log messages
Service schedule considerations
Creating a service schedule
Modifying a service schedule
Adding a time period
Modifying a time period
Deleting a time period
Setting the active service schedule
Deleting a service schedule
Capacity Balancing service
Capacity Balancing service processing
Compression/Encryption service
Compression/Encryption service processing
Understanding compression statistics
Changing compression settings
How to change compression settings
Exclusion criteria
Content Verification service
Content Verification service processing
Configuring the Content Verification service
Disposition service
Duplicate Elimination service
Duplicate Elimination service processing
Understanding the Duplicate Elimination page
Fast Object Recovery service
Garbage collection service
Garbage Collection service processing
Object deletions
Transaction log cleanup
Other Garbage Collection service functions
Configuring the Garbage Collection service
Migration service
Considerations for migrations on RAIN systems
Target storage requirements for SAIN systems
Migration procedure
Migration page
Configuring a data migration
Configuring a migration on a RAIN system
Configuring a migration on a SAIN system
Monitoring a data migration
Information about the current data migration
Information about the last data migration
Managing a data migration
Changing the performance level
Pausing or resuming a migration
Canceling a migration
Protection service
Ingest tier data protection level
Protection service processing
Protection service triggers
HCP S Series Balancing service
HCP S Series Balancing service processing
Best practices in configuring HCP S Series Balancing
HCP S Series Balancing service monitoring
Scavenging service
Shredding service
Shredding service processing
Sending shredding messages to syslog servers
Understanding shredding statistics
Changing shredding settings
Duplicate elimination and shredding
Erasure coding and shredding
Shredding service trigger
Storage Tiering service
Moving copies of objects among storage tiers
Maintaining the correct number of object copies on each tier
Making objects metadata-only
Storage Tiering service processing
Understanding storage tiering statistics
System security
Setting network security
Enabling or disabling network security services on HCP nodes
Setting exclusive Support access credentials
Applying the exclusive Support access credentials package
Managing domains and SSL server certificates
About domains
Domain names
Domains and DNS
About SSL server certificates
Certificates for domains
Common names
Certificate selection
Managing domains and certificates
Creating a domain
Adding a certificate to a domain
Creating a CSR
Deleting a certificate or CSR
Downloading a CSR
Installing the certificate returned for an HCP generated CSR
Installing a certificate created outside HCP
Controlling access to the System Management Console
Valid IP address list entries
IP address list handling
Controlling access to HCP through the management API
Enabling the HCP management API
Specifying IP addresses to be allowed access to HCP
Specifying IP addresses to be denied access to HCP
Controlling access to the Search Console for the default tenant
Configuring Active Directory or Windows workgroup support
About Active Directory
User authentication with Active Directory
HCP configuration for Active Directory support
Service principal name attributes for HCP
Configuring support for Active Directory
Configuring support for Windows workgroups
Refreshing the Active Directory status
Clearing the Active Directory cache
Configuring connections to RADIUS servers
Understanding the RADIUS server list
Adding a RADIUS server
Testing the connection to a RADIUS server
Testing the connection to a RADIUS server
Modifying a RADIUS server
Reordering RADIUS servers
Deleting a RADIUS server
Configuring a key management server
Authenticating HCP and KM server using SSL
Creating a CSR
Deleting a CSR
Downloading a CSR
Key management
Adding a key management server
Modifying key manager settings
Viewing a key management server
Deleting a key management server
Encrypting storage pools
Setting the systemwide permission mask
Setting the systemwide permission mask for an HCP system
System monitoring
Understanding the HCP system log
Viewing the complete event log
Viewing the system security log
Understanding log messages
Managing the message list
Configuring syslog logging
System log messages sent to syslog servers
Enabling syslog logging
Adding an IP address to the syslog server list
Testing syslog connections
HCP system log messages
Configuring SNMP
Log messages sent to SNMP managers
Enabling and configuring SNMP
Enabling SNMP for HCP
Specifying IP addresses to be allowed access to HCP through SNMP
Specifying IP addresses to be denied access to HCP through SNMP
Specifying how HCP should handle IP addresses that appear in both or neither of the Allow and Deny lists
Specifying one or more external SNMP manager IP addresses
Testing SNMP connections
Viewing and downloading the HCP-MIB.txt file
Using SNMP to view or change HCP settings
Monitoring HCP performance using Prometheus
Enabling and configuring Prometheus
Alert rules
Viewing HCP metrics in Grafana
Resetting Prometheus settings
Disabling Prometheus
HCP performance metrics collected by Prometheus
Configuring email notification
Enabling email notification
Specifying the email server
Testing the connection to the email server
Constructing the email message template
Modifying the template HCP uses for email notification about log messages
Email template variables
Restoring the default template
Changing the email template back to the default
Specifying email recipients
Monitoring resources
About the resource usage graphs
CPU
Logical volumes
Memory
Networks
Managing the resource usage graphs
Switching graphs
Setting the scope
Zooming
Setting the amount by which zooming increases or decreases
Viewing details for a point in time
Specifying a time period
Scrolling
Setting the percent by which scrolling shifts the visible time period
Viewing system log messages on the Resources page
Generating chargeback reports
About chargeback reports
Generating a chargeback report
Generating a chargeback report
Chargeback statistics collection
Chargeback report content
Sample chargeback report
Chargeback page graphs
Checking the status of your nodes
Request-specific return codes (node status)
Response body (node status)
Example: Retrieving node status
Configuring the Hitachi Device Manager connection
Configuring HCP to work with HDvM
Preparing and downloading health check reports
Using the System Management Console to prepare and download health check reports
Health check reports archive contents
Health check report signatures
Licensing
Viewing a License
Uploading a license
Licenses and Features
Troubleshooting
Running diagnostics
ping
traceroute
dig
Route
showmount
fchbainfo
ethtool
Working with HCP internal logs
Adding a comment to the internal logs
Downloading internal logs for one or more storage nodes
System Management Console Alerts
Overview page alerts
Hardware page alerts
Storage node page alerts
Storage page alerts
Networks page alerts
Tenants page alerts
Domains and certificates page alerts
Active directory page alerts
Zero-copy failover behavior
Storage setup for zero-copy failover
Failing over and failing back
SNMP MIB support
Supported standard MIB files
Walking the MIB
Configuring DNS for HCP
DNS advantages
Zones
Secondary zones and stub zones
Configuring an HCP secondary zone or stub zone in Windows
Configuring an HCP secondary zone in Windows
Configuring an HCP stub zone in Windows
Verifying the configuration
DNS considerations for service by remote systems
Configuring Active Directory to support HCP
Prerequisites for configuring support for HCP in AD
Considerations for the information you need to supply
Required permissions for Active Directory Domain
Configuring Active Directory to support HCP
Browser configuration for single sign-on with Active Directory
Configuring Windows Internet Explorer for single sign-on
Configuring Mozilla Firefox for single sign-on
SSL server certificate providers
Managing a Tenant and Its Namespaces
Introduction to Hitachi Content Platform
About Hitachi Content Platform
Object-based storage
Namespaces and tenants
Namespace access
Namespace access protocols
HCP Namespace Browser
HCP metadata query API
HCP Search Console
Object representation
Tenant and namespace properties
Namespace quota
Storage quotas
Data protection level
Cryptographic hash algorithm
Retention mode
Namespace owner
Namespace tags
Default retention setting
Default shred setting
Default index setting
Default POSIX UID, GID, and permissions
Retention-related properties
Ownership and permission changes for objects under retention
Custom metadata operations for objects under retention
Protocol optimization and directory usage
XML checking for custom metadata
Versioning
Compatibility property
Disposition
Automatic abort of multipart uploads
Data access permission masks
Minimum data access permissions
Access control lists
Replication
Replication benefits
Replication implementation
Replication collision handling
Object content collisions
System metadata collisions
Custom metadata collisions
Access control list collisions
Configuration collisions
Retention class collisions
Service plans
System-level administrative access
General administrative information
Tenant Management Console
About the Console
Tenant Management Console URL
Logging in
Using the Tenant Management Console
Refreshing pages
Submitting changes
Viewing HCP documentation
Changing your password
Logging out
Administrative responsibilities
Managing accounts
User and group accounts
User accounts
Group accounts
Administrative roles and permissions
Available roles
Permissions granted by roles
Data access permissions
User authentication
Starter account
Working with user accounts
About the Users page
Understanding the user account list
Managing the user account list
Paging
Sorting
Filtering
Creating a user account
Modifying a user account and its roles
Deleting a user account
Working with group accounts
Groups page
Paging
Sorting
Filtering
Creating group accounts
Modifying a group account
Deleting a group account
Changing the allow namespace management property for a user or group account
Changing the data access permissions for a user or group account
Specifying permissions for any number of namespaces
Changing the permissions for an individual namespace
Dissociating a namespace from a user or group account
User account and login settings
Change one or more login settings
Managing the current tenant
Tenant Overview page
Tenant statistics
Major tenant events
Tenant alerts
Tenant features
Tenant contact information
Tenant permission mask
Tenant description
Configuring the tenant
Changing the tenant contact information
Changing the tenant permission mask
Changing the tenant description
Enabling or disabling system-level administrative access
Controlling access to the Tenant Management Console
Controlling access to HCP through the management API
Controlling access to the Search Console
Monitoring the tenant
Viewing the complete tenant event log
Viewing the tenant security log
Viewing the tenant compliance log
Understanding log messages
Managing the message list
Viewing the Active Directory log
Enabling syslog logging
Enabling SNMP logging
Configuring email notification
Enabling email notification
Testing email notification
Constructing the email message template
Modify the email notification template
Restoring the default template
Specifying email recipients
Understanding the recipients list
Modifying rows in the recipients list
Monitoring and managing replication
Tenant-level view of replication
Managing the namespace list
Paging
Sorting
Filtering
Namespace-level view of replication
Up-to-date-as-of time
Data transmission rate
Operation rate
Selecting or deselecting namespaces for replication
Generating chargeback reports
About chargeback reports
Generating a chargeback report
Chargeback statistics collection
Chargeback report content
Sample chargeback report
Chargeback page graphs
Managing namespaces
About the Namespaces page
Understanding the namespace list
Managing the namespace list
Paging
Sorting
Filter using filter fields
Filter using tag control
Namespace Overview panel
Display the namespace Overview panel
Namespace URL
Namespace owner
Objects section
Usage section
Major namespace events
Namespace alerts
Namespace features
Namespace permission mask
Namespace description
Creating a namespace
Configuring a namespace
Changing the namespace name
Changing the namespace permission mask
Changing the namespace description
Changing the namespace storage quotas
Changing the namespace owner
Changing the namespace tags
Changing the default retention setting
Changing the default shred setting
Allowing object overwrites
Changing the default index setting
Changing minimum data access permissions
Enabling the use of ACLs
Changing the option to enforce ACLs
Changing retention-related settings
Enabling or disabling XML checking for custom metadata
Configuring object versioning
Changing the compatibility setting
Changing disposition settings
Changing the automatic abort time for multipart uploads
Changing replication options
Changing the service plan
Changing the retention mode
Namespace-level CORS rules configuration
Request elements (CORS rules)
CORS configuration template
Configuring CORS rules for a namespace
Configuring namespace access protocols
Namespace access protocol configuration
Display the Protocols panel
Changing the protocol optimization for a namespace
IP addresses for namespace access
Add entries in Allow and Deny lists
Remove entries in Allow and Deny lists
Valid Allow and Deny list entries
Allow and Deny list handling
User authentication options
Configuring the REST, S3 compatible, and WebDAV APIs
REST, S3 compatible, and WebDav API configuration
Considerations for the S3 compatible API
Enabling REST, S3 compatible, and WebDAV access to a namespace
Set the IP addresses to be allowed or denied access
Configuring the CIFS protocol
CIFS protocol configuration
CIFS case sensitivity
Enabling CIFS access to a namespace
Settings section
Allow/Deny section
CIFS case sensitivity
Configuring the NFS protocol
NFS protocol configuration
Enabling NFS access to a namespace
Settings section
Allowed IP Addresses section
Configuring the SMTP protocol
SMTP protocol configuration
Enabling SMTP access to a namespace
Settings section
Allow/Deny section
Emails section
Changing the default settings for namespace creation
Setting the maximum number of namespaces per user
Monitoring a namespace
Viewing the complete namespace event log
Viewing the namespace compliance log
Working with unavailable objects
Working with irreparable objects
Displaying irreparable objects
About irreparable objects
Acknowledge irreparable objects
Working with nonreplicating objects
Displaying nonreplicating objects
About nonreplicating objects
Deleting a namespace
Managing search and indexing
Search and indexing
Content classes and content properties
Metadata query engine indexing of custom metadata
Content class and content property workflow
Content property definitions
Content property names
Content property expressions
Content property data types
Format for the integer and float data types
Datetime data type formats
Multivalued content properties
Content properties extracted from sample XML
Content property files
About the Search page
Managing the content class list
Paging
Sorting
Filtering
Understanding the content property list for a content class
Creating a content class
Managing content properties for a content class
Workflow for adding, modifying, and deleting content properties
Adding content properties individually
Extracting content properties from sample XML
Importing content properties from a content property file
Testing content properties
Exporting content properties
Changing the namespaces associated with a content class
Reindexing namespaces associated with a content class
Renaming a content class
Deleting a content class
Managing search and indexing for an individual namespace
Displaying the namespace Search panel
Setting search and indexing options
Reindexing an individual namespace
Working with retention classes
About retention classes
Display the Retention Classes panel
Understanding the retention class list
Creating a retention class
Modifying a retention class
Deleting a retention class
Using privileged delete
About privileged delete
Object specification
Performing a privileged delete
Tenant Management Console alerts
Tenant Overview page alerts
Namespaces page alerts
Namespaces Overview panel alerts
Search page alert
Users page alert
Tenant log messages
Tenant log messages
Browser configuration for single sign-on with Active Directory
Configuring Windows Internet Explorer for single sign-on
Configuring Mozilla Firefox for single sign-on
Replicating tenants and namespaces
Geographically distributed data protection
About geo-protection
Protection types
Distribution methods for erasure-coded protection
Choosing a protection type
How replication works
What is replicated?
Replication of HCP tenants
Replication of the default tenant
Replication service processing
Geo-Distributed Erasure Coding service processing
Replication Verification service processing
Unavailable and irreparable erasure-coded objects
Replicated systems
Replication and Active Directory authentication
Replication and RADIUS authentication
Replication topologies
Simple active/active replication
Active/active replication ring
Configuring an active/active replication ring
Active/active replication ring topology
Using active/active replication ring topology
Fully connected active/active replication
Configuring a fully connected active/active replication topology
Fully connected active/active replication topology as erasure coding topology
Simple active/passive replication
Active/passive many-to-one replication
Active/passive chained replication
Configuring an active/passive chained replication
Active/passive chained replication topology details
Active/passive one-to-many replication
Using active/passive one-to-many replication topology to upgrade HCP systems from RAIN to SAIN
Active/active replication with disaster recovery support
Many-to-one replication with disaster recovery support
Creating many-to-one replication with disaster recovery support
Bidirectional active/passive replication
Bidirectional active/passive chained replication
Bidirectional active/passive replication with disaster recovery support
Failover and failback
Failover and failback with active/active links
Failover and failback with active/passive links
Replication collisions
Object content collisions
System metadata collisions
Custom metadata collisions
Access control list collisions
Configuration collisions
Retention class collisions
Considerations for cross-release replication
Configuring SSL for replication
Sharing SSL server certificates
Downloading an SSL server certificate
Uploading a trusted replication server certificate
Deleting a trusted replication server certificate
Working with replication links
Link properties
Considerations for creating a replication link
Creating a replication link
Considerations for specifying link content
Specifying link content
Specifying link content for an active/active link
Adding HCP tenants in an active/active link
Removing HCP tenants in an active/active link
Selecting HCP namespaces for tenants in an active/active link
Deselecting HCP namespaces for tenants in an active/active link
Adding default-namespace directories in an active/active link
Removing default-namespace directories in an active/active link
Specifying link content for an active/passive link
Adding HCP tenants in an active/passive link
Removing HCP tenants in an active/passive link
Selecting HCP namespaces for tenants in an active/passive link
Deselecting HCP namespaces for tenants in an active/passive link
Adding default-namespace directories in an active/passive link
Removing default-namespace directories in an active/passive link
Adding chained links in an active/passive link
Removing chained links in an active/passive link
Filtering item selection lists
Considerations for modifying a replication link
Modifying a replication link
Changing link properties
Changing automatic failover and failback settings
Considerations for deleting a replication link
Deleting a replication link
Working with erasure coding topologies
About erasure coding topologies
Erasure coding topology properties
Supported replication topologies
Erasure coding topology retirement
Erasure coding topology replacement
Erasure coding topology replacement process
Considerations for replacing an erasure coding topology
Erasure coding topology replacement procedure
Considerations for creating an erasure coding topology
Creating an erasure coding topology
Considerations for specifying the tenants for an erasure coding topology
Specifying the tenants for an erasure coding topology
Adding and removing tenants
Filtering the tenant lists
Filtering
Considerations for modifying an erasure coding topology
Modifying an erasure coding topology
Retiring an erasure coding topology
Considerations for deleting an erasure coding topology
Deleting an erasure coding topology
Understanding the erasure coding topology list
Understanding erasure coding topology details
Monitoring replication
Understanding the replication link list
General link information
Link overview
Data transmission rate
Operation rate
Remote storage space
Tenants view
Display the Tenants panel
Understanding the tenant list
Managing the tenant list
Paging
Sorting
Filtering
Tenant replication details
Controlling the Tenant Management Console replication display
System Management Console alerts
Managing replication
Scheduling activity on a replication link
About replication schedules
Modifying a replication schedule
Overriding a replication schedule
Suspending and resuming activity on an individual link
Pausing and resuming replication or recovery of a tenant
Pausing and resuming tenant replication or recovery
Automatically paused tenant replication or recovery
Tenant name collisions
Namespace name collisions
Namespace compliance issues
Content class collisions
User account collisions
Group account collisions
Tenant conflicts
Labeled holds in a replication topology
Replication in an environment with mixed HCP versions
Shutting down and reestablishing all replication links
Selecting the network for replication
Selecting the replication network
Displaying the zone definition for the replication network domain
Managing DNS failover
About DNS failover
Enabling or disabling DNS failover
Alternatives to DNS failover
Managing the Replication Verification service
Changing link connectivity failure reporting
Managing failover and failback
Failover and failback workflows
System failure workflow with an active/active link
Primary system failure workflow
Replica failure workflow
Failing over
Recovering from a failure
Restoring a link
Failing back an active/active link
Recovering the data after a primary system failure
Failover and failback considerations
Failover and failback in an active/passive many-to-one topology
Failover and failback in an active/passive chained topology
Scenario: System A fails
Scenario: System B fails
Scenario: System C fails
Scenario: Systems A and B fail
Scenario: Systems A and C fail
Scenario: Systems B and C fail
Failover and failback in an active/passive one-to-many topology
Failover and failback in an active/passive many-to-one topology with disaster recovery support
Reenabling user accounts disabled on the replica
Setting advanced replication options
Changing the custom performance level
Changing the broken-link reporting interval
HCP Management API Reference
Introduction to the HCP management API
What you can do with the management API
Who can use the management API
Resources and properties
Supported methods
Input and output formats
Query parameters
HCP product-specific response headers
Security-related response headers
Enabling the management API in the Consoles
Access and authentication
URL for HCP access through the management API
Using an IP address in URL
Using a hosts file
URL considerations
Authentication
HCP authentication through the management API
Authentication token
Authorization header
Active Directory user authentication through the HCP management API
Active Directory authentication token
Active Directory authorization header
Resources
Content class resources
Example: Creating a content class
Example: Retrieving a list of content classes
Erasure coding topology resources
Example: Retrieving a list of eligible replication links
Example: Creating an erasure coding topology
Example: Retrieving a list of eligible tenants
Example: Adding a tenant to an erasure coding topology
Example: Retrieving an erasure coding topology
Example: Retiring an erasure coding topology
Health check report resources
Example: Preparing health check reports for download
Example: Downloading the health check reports
Example: Retrieving the health check reports download status
Example: Canceling the health check reports
License resources
Example: Retrieving a premium storage license list
Example: Uploading a new license
Log resources
Example: Start log packaging
Example: Download the logs
Example: Retrieving the log download status
Example: Canceling a log download
Example: Marking the download log
Namespace resources
Example: Creating an HCP namespace
Example Changing the compliance settings for an HCP namespace
Example Configuring the REST API for an HCP namespace
Network resources
Example: Enabling advanced downstream DNS configuration
Example: Checking the advanced DNS configuration
Node statistics resource
Example: Retrieving node statistics
Paging, sorting, and filtering
Paging through resource lists
Sorting resource lists
Filtering resource lists
Replication resources
Example: Creating a replication link
Example: Retrieving a replication certificate
Example: Adding a replication certificate
Example: Retrieving a list of eligible local candidates
Example: Adding an HCP tenant to a replication link
Example: Setting the schedule for a replication link
Example: Failing over a replication link
Retention class resources
Example: Creating a retention class
Example: Retrieving a list of retention classes
Service statistics resource
Example: Retrieving service statistics
Support access credentials resource
System-level group account resources
Example: Retrieving system-level group accounts
Example: Retrieving system-level group account information
System-level user account resources
Example: Retrieving system-level user accounts
Example: Retrieving system-level user account information
Example: Changing a user account password with a query parameter
Example: Changing a user account password in the request body
Tenant resources
Example: Creating an HCP tenant
Example: Setting Tenant Management Console security for a tenant
Example: Generating a chargeback report for a tenant
Tenant-level group account resources
Example: Creating a group account
Example Retrieving group accounts
Tenant-level user account resources
Example: Creating a user account
Example: Changing the roles associated with a user account
Example: Changing the data access permissions associated with a user account
Example: Changing a user account password in the request body
Example: Resetting the security user passwords for a tenant
Data types
Common property values
availableServicePlan
certificate
certificates
chargebackData
chargebackReport
cifsProtocol
complianceSettings
connection
consoleSecurity
contactInfo
content
contentClass
contentProperty
contentProperties
cors data type
customMetadataIndexingSettings
dataAccessPermissions
ecTopology
emailNotification
emailTemplate
failoverSettings
groupAccount
healthCheckDownload
healthCheckDownloadStatus
healthCheckPrepare
httpProtocol
ipSettings
license
licenses
link
local (data type for replication link failoverSettings local property)
local (data type for replication link schedule local property)
logDownload
logDownloadPrepare
logDownloadStatus
namespace
namespaceDefaults
namespacePermission
networkSettings
nfsProtocol
node ()
node
nodes
nodeStatistics
protocols
recipient
recipients
remote (data type for replication link failoverSettings remote property)
remote (data type for replication link schedule remote property)
replicationCollisionSettings
replicationLink
replicationLinks
replicationService
retentionClass
schedule
searchSecurity
service
services
serviceStatistics
smtpProtocol
Specifying retention values
statistics (data type for replication link statistics property)
statistics (data type for tenant and namespace statistics resources)
Support access credentials data type
tenant (data type for replication link content tenant resource)
tenant (data type for tenant resource)
tenantCandidate
tenantCandidates
transition
updatePasswordRequest
userAccount (tenant level)
versioningSettings
Usage considerations
Choosing an access method
Generating templates for resource creation
Modifying resources
Session cookie encoding
HTTP status codes for the HCP management API
Sample Java application
What the application does
Assumptions
Required libraries
Input JSON files
JSON file for creating the HCP tenant
JSON file for modifying the initial user account
JSON file for creating the user account with the compliance and monitor roles
JSON file for configuring the Tenant Management Console
JSON file for modifying the tenant
JSON files for creating the namespaces
JSON file for modifying a namespace
JSON file for configuring the REST API
JSON file for creating the user account with no roles
JSON file for granting data access permissions to the user account
JSON file for creating the retention class
JSON file for creating the replication link
JAVA application
Management API XML schema
Using the Hitachi API for Amazon S3
Introduction to Hitachi Content Platform
About Hitachi Content Platform
About the Hitachi API for Amazon S3
Other bucket access methods
Namespace access protocols
HCP Namespace Browser
HCP metadata query API
HCP Search Console
User accounts
Data access permissions
Examples in this help
Bucket and object properties
Bucket names
Object names
Forward slashes in object names
Object naming considerations
Retention
Retention terms
Object retention settings
Deleting an object under retention
Holding an object
Holding an object using labeled holds
Retention classes
Retention-related request headers
Retention-related response headers
Specifying retention settings
Specifying a date and time
Specifying an offset
Custom metadata
Storing custom metadata with the S3 compatible API
Retrieving custom metadata with the S3 compatible API
Custom metadata usage considerations
Bucket owners
Object owners
Access control lists
ACL permissions
ACL grantees
Canned ACLs
Specifying ACLs
Specifying an ACL with headers
Specifying an ACL in the request body
Removing an ACL
Versioning
Allocated space
Search
Data access permission masks
Replication collisions
Object content collisions
Custom metadata collisions
Access control list collisions
Access and authentication
URLs for access to HCP
Targeting a tenant
Targeting a bucket
Targeting an object
Using SSL security
Using an IP address in a URL
Using a hosts file
URL considerations
Authentication
AWS authentication
Active Directory authentication
Presigned URLs
Signatures
Anonymous access
Invalid credentials
Changing your password
Requests and responses
Request line
Common request headers
Response status line
Common response headers
Error response body
Error codes
Working with buckets
Creating a bucket
Listing the buckets you own
Checking the existence of a bucket
Adding an ACL to a bucket
Retrieving the ACL for a bucket
Enabling or disabling versioning for a bucket
Checking the versioning status of a bucket
Listing bucket contents (version 1)
Listing bucket contents (version 2)
Listing the in-progress multipart uploads in a bucket
Deleting a bucket
Working with objects
Storing an object
Creating a folder
Checking the existence of an object or folder
Adding an ACL to an object
Retrieving the ACL for an object
Copying an object
Conditionally copying an object
Retrieving an object
Conditionally retrieving an object
Overriding response headers
Deleting an object or folder
Deleting multiple objects
Working with multipart uploads
About multipart uploads
Creating an object by multipart upload
Considerations for working with multipart uploads
Support for multipart uploads
Part size and count
Automatic abort of multipart uploads
Client timeouts
Creation date and time for multipart objects
Retention setting for multipart objects
Multipart uploads and versioning
Multiple multipart uploads for objects with the same name
Multipart uploads for objects under retention or on hold
Multipart uploads and replicated buckets
Initiating a multipart upload
Uploading a part of a multipart upload
Uploading a part of a multipart object by copying
Listing the parts of a multipart upload
Completing a multipart upload
Aborting a multipart upload
Working with POST object uploads
About POST object uploads
POST object upload authentication
Security policies
Executing a POST object upload
Using CORS to process cross-domain requests
CORS use cases
CORS limits
CORS rules configuration
HCP permissions for CORS configuration
Request header and elements
Example: PUT bucket request
Example: GET bucket request
Example: DELETE bucket request
CORS request validation
Usage considerations
Hostname and IP address considerations
Folder structures
Concurrent writes of the same object
Failed PUT requests to store objects
Empty objects
Deleting objects under repair
Multithreading
Persistent connections
Connection failure handling
Session cookie encoding
Quick reference
Alternative authentication method
URLs with HCP authentication
HCP authentication
Using third-party tools with the Hitachi API for Amazon S3
General setup information for third-party tools
s3curl setup
Specifying an access key and secret key
Specifying a tenant
Sample Java application
Assumptions
What the application does
Required libraries
Java application
Hitachi API for Amazon S3 XML schema
Using a Namespace
Overview
Introduction to Hitachi Content Platform
About Hitachi Content Platform
Object-based storage
Namespaces and tenants
Namespace access
Namespace access protocols
HCP Namespace Browser
HCP metadata query API
HCP Search Console
HCP nodes
Permissions
Replication
Operations
Operation restrictions
Supported operations
Prohibited operations
Object representation
Object representation with the REST API
Object representation with WebDAV, CIFS, and NFS
Root directories
Sample data structure
Metadirectories
Metafiles
Complete metadata structure
Object properties
Data protection level
Cryptographic hash value
Object ingest time and change time
Retention
Object retention settings
Deleting object and versions under retention
Holding an object
Holding an object using labeled holds
Retention classes
Viewing retention settings
Specifying retention settings
Retention setting values
Specifying a date and time
Specifying an offset
atime synchronization with retention
Triggering atime synchronization for existing objects
Removing the association
How atime synchronization works
atime synchronization example
Shredding
Indexing
Ownership
POSIX metadata
POSIX time attributes
POSIX ownership and permissions
Viewing POSIX permissions
Octal permission values
POSIX ownership and permissions for new items
Changing POSIX ownership and permissions for existing items
Versioning
Creating versions
Retrieving and listing versions
Deleting objects with versioning enabled
Purging objects
Custom metadata
Access control lists
ACL permissions
ACL body
ACL examples
ETags
Replication collision handling
Object content collisions
System metadata collisions
Custom metadata collisions
Access control list collisions
REST API
Accessing a namespace with the REST API
URLs for namespace access using the REST API
URL formats
Using an IP address in a URL
URL considerations
Authenticating namespace access
HCP authentication through the REST API
Authentication token
Authorization header
Active Directory user authentication through the REST API
Active Directory authentication token
Active Directory authorization header
Transmitting data in compressed format
Responding system
Working with objects and versions
Storing an object or version of an object
Copying an object or version of an object
Checking the existence of an object or multiple versions of an object
Listing object versions
Retrieving an object or multiple versions of an object
Deleting an object or object versions and using privileged delete
Purging an object and using privileged purge
Conditional operations
Working with directories
Creating an empty directory
Checking the existence of a directory
Listing directory contents
Deleting an empty directory
Working with system metadata
Specifying metadata on object creation
Modifying object metadata
Working with annotations
Storing an annotation
Checking the existence of an annotation
Listing annotations for an object or version
Retrieving annotations for objects and versions
Deleting annotations
Working with ACLs
Storing an ACL
Checking the existence of an ACL
Retrieving ACLs for objects and versions
Deleting an ACL
Retrieving namespace information
Listing accessible namespaces
Retrieving settings for an individual namespace
Listing retention classes
Listing namespace and user permissions
Listing namespace statistics
REST API usage considerations
Data chunking with write operations
Using the REST API with objects open for write
Failed REST API write operations
Storing zero-sized files with the REST API
Persistent connections with the REST API
Connection failure handling
Multithreading with the REST API
HTTP 500 and 503 status code considerations
Session cookie encoding
WebDAV
Using WebDAV
WebDAV methods
URLs for WebDAV access to a namespace
URL formats
URL considerations
WebDAV properties
Live and dead properties
HCP-specific metadata properties for WebDAV
Storing dead properties as custom metadata
WebDAV status codes
WebDAV examples
Example: Storing an object
Example: Retrieving the index setting for an object
Example: Changing the retention setting for an object
Example: Storing a dead property as custom metadata
WebDAV usage considerations
Basic authentication with WebDAV
WebDAV object locking
Failed WebDAV write operations
Storing zero-sized files with WebDAV
WebDAV client timeouts with long-running requests
Persistent connections with WebDAV
Multithreading with WebDAV
CIFS
Using CIFS
Namespace access with CIFS
CIFS return codes
CIFS examples
Example: Storing an object
Example: Changing a retention setting
Example: Retrieving an object
CIFS usage considerations
CIFS case sensitivity
CIFS permission translations
Creating an empty directory with atime synchronization in effect
CIFS lazy close
Using CIFS with objects open for write
Failed CIFS write operations
Storing zero-sized files with CIFS
Out-of-order writes with CIFS
Temporary files created by Windows clients
Multithreading with CIFS
NFS
Using NFS
Namespace access with NFS
NFS return codes
NFS examples
Example: Storing an object
Example: Changing a retention setting
Example: Using atime to set retention
Example: Creating a symbolic link
Example Retrieving an object
NFS usage considerations
NFS lazy close
Using NFS with objects open for write
Failed NFS write operations
Storing zero-sized files with NFS
Out-of-order writes with NFS
NFS reads of large objects
Walking large directory trees
NFS delete operations
NFS mounts on a failed node
Multithreading with NFS
Namespace Browser
Introduction to the Namespace Browser
About the Namespace Browser
Namespace Browser sessions
Accessing the Namespace Browser
Logging into the Namespace Browser as an authenticated user
Logging into the Namespace Browser anonymously
Common elements
Changing your password
Working with namespace contents
Listing directory contents
Directory listing
Showing and hiding deleted objects and directories
Listing object versions
Listing versions of deleted objects and directories with the same name
Accessing objects
Accessing old versions of an object
Storing objects and versions
Deleting objects and symbolic links
Creating directories
Viewing namespace information
Viewing accessible namespaces
Namespace information
Managing the namespace list
Paging
Sorting
Filter using filter fields
Filter using tag control
Viewing namespace statistics and description
Namespace statistics
Viewing permissions
Namespace permissions
Viewing retention classes
General usage considerations
Choosing an access protocol
Hostname and IP address considerations
Using a hosts file
Object naming considerations
Naming conventions for email objects
Directory structures
Shredding considerations
Non-WORM objects
Moving or renaming objects
Deleting objects under repair
Deleting directories
Multithreading
Status code considerations
REST API reference
HTTP methods supported by the REST API
DELETE
GET, except for namespace information requests
GET of namespace information
HEAD
POST
PUT
HTTP status codes with the REST API
REST API non-HTTP response headers
Standard HTTP response headers for the REST API
Java classes for examples
GZIPCompressedInputStream class
WholeIOOutputStream class
Browser configuration for single sign-on with Active Directory
Configuring Windows Internet Explorer for single sign-on
Configuring Mozilla Firefox for single sign-on
HCP Metadata Query API Reference
Introduction to the HCP metadata query API
About the metadata query API
Types of queries
Query results
Object-based query results
Operation-based query results
Paged queries
Object index
Access and authentication
Request URL
Connecting using a hostname
Connecting using an IP address
Connecting using a hosts file
Authentication
HCP authentication through the metadata query management API
Authentication token
Authorization header
Active Directory user authentication through the metadata query management API
Active Directory authentication token
Active Directory authorization header
Query requests
Request format
Object-based query requests
XML request body for object-based queries
JSON request body for operation-based queries
Request object body contents
Top-level entry
object entry
sort entry
facets entry
Query expressions
Text-based criteria
Property-based criteria
Query expression considerations
customMetadataContent property
aclGrant property
Query expression examples
Paged queries with object-based requests
Paged queries with 100,000 or fewer matching objects
Paged queries with more than 100,000 matching objects
Operation-based query requests
XML request body for operation-based queries
JSON request body for operation-based queries
Request operation body contents
Top-level entry
operation entry
lastResult entry
systemMetadata entry
Paged queries with operation-based requests
Object properties
Query responses
XML response bodies
XML reponse body for object-based queries
XML response body for operation-based queries
JSON response bodies
JSON response body for object-based queries
JSON response body for operation-based queries
Response body contents
query entry
resultSet entry
object entry
status entry
contentProperties entry
facets entry
HTTP status codes
HTTP response headers
Examples
Object-based query examples
Example: Querying for custom metadata content
Example: Using a paged query to retrieve a list of all objects in a namespace
Example Using a faceted query to retrieve object information
Example: Querying for replication collisions in a namespace
Example: Listing content properties
Operation-based query examples
Example: Retrieving all operation records for all existing and deleted objects in a directory
Example: Retrieving metadata for changed objects
Example: Using a paged query to retrieve a large number of records
Example: Checking for replication collisions
Usage considerations
Searching namespaces
Introduction to searching in HCP
About Hitachi Content Platform
Object based storage
Namespaces and tenants
Object metadata
Retention settings
Retention mode
About searching namespaces
Search Console
Search facilities
Indexes
Content properties
Index settings
Searchable namespaces
Using the Search Console
Search Console URL
Search Console sessions
Logging into the Search Console
Logging out of the Search Console
Search Console pages and navigation
Viewing search documentation
Changing your password
Working with simple searches
About simple searches
Search terms
Metadata query engine search terms
Directory paths and object names
Multiple exact phrases
Wildcards
Boolean criteria
Examples of simple searches
Performing a simple search
Working with search results
About search results
Initial search results for individual objects
Initial results with the metadata query engine
Viewing returned objects
Showing results details
Understanding returned metadata
POSIX permissions
Octal permission values
Paging through search results
Sorting search results
Showing or hiding the query
Filtering search results
Search results page
Filtering by retention setting
Filtering by retention class
Filtering by hold status
Filtering by namespace
Performing operations on returned objects
Placing all the objects in the current search results on hold
Releasing all held objects in the current search results
Deleting all objects in the current search results except those that are under retention or on hold
Deleting all objects in the current search results, including those that are under retention but excluding those that are on hold
Purging all versions of all the objects in the current search results except those that are under retention or on hold
Purging all versions of all the objects in the current search results, including those that are under retention but excluding those that are on hold
Changing the ownership of all objects in the current search results
Setting an ACL on each object in the current search results
Updating the existing ACLs for all objects in the current search results
Access control lists
ACL permissions
XML format
Exporting search results
Working with structured searches
About structured searches
Properties for structured searches
Properties for structured queries with the metadata query engine
Content classes
Specifying an owner
Specifying an ACL grant
Query for objects with ACLs that grant permissions to a specified user
Query for objects with ACLs that grant permissions to the user account you’re using to access the Console
Query for objects with ACLs that grant permissions to an AD group
Query for objects with ACLs that grant permissions to all users, including those that access the namespace anonymously
Query for objects with ACLs that grant permissions to all authenticated users
Specifying dates
Selecting a calendar date
Typing a date
Selecting the current date and time
Performing a structured search
Examples of structured searches
Working with advanced searches
About advanced searches
Criteria for advanced queries with the metadata query engine
Query expressions
Criterion format
Boolean operators
Text-based property values
Multiple values for a single property
Value ranges
Wildcard characters
Query expression considerations
Properties for advanced queries
Criteria for advanced queries with the metadata query engine
customMetadataContent property
aclGrant property
Content properties
Performing an advanced search
Working with saved queries
Saving a query
Viewing saved queries
Running a saved query
Editing a saved query
Publishing a feed for a saved query
Deleting a saved query
Browser configuration for single sign-on with Active Directory
Configuring Windows Internet Explorer for single sign-on
Configuring Mozilla Firefox for single sign-on

Back to home page