-
StorageClass
2019-07-15 20:30:21本文个人博客地址:...StorageClass 1. StorageClass概述 StorageClass提供了一种描述存储类(class)的方法,不同的class可能会映射到不同的服务质量等级和备份策略或其他策略等。 StorageClass 对象中包含...本文个人博客地址:https://www.huweihuang.com/kubernetes-notes/storage/storage-class.html
StorageClass
1. StorageClass概述
StorageClass
提供了一种描述存储类
(class)的方法,不同的class可能会映射到不同的服务质量等级和备份策略或其他策略等。StorageClass
对象中包含provisioner
、parameters
和reclaimPolicy
字段,当需要动态分配PersistentVolume
时会使用到。当创建StorageClass
对象时,设置名称和其他参数,一旦创建了对象就不能再对其更新。也可以为没有申请绑定到特定 class 的 PVC 指定一个默认的StorageClass
。StorageClass对象文件
kind: StorageClass apiVersion: storage.k8s.io/v3 metadata: name: standard provisioner: kubernetes.io/aws-ebs parameters: type: gp2 reclaimPolicy: Retain mountOptions: - debug
2. StorageClass的属性
2.1. Provisioner(存储分配器)
Storage class 有一个
分配器(provisioner)
,用来决定使用哪个卷插件分配 PV,该字段必须指定。可以指定内部分配器,也可以指定外部分配器。外部分配器的代码地址为: kubernetes-incubator/external-storage,其中包括NFS
和Ceph
等。2.2. Reclaim Policy(回收策略)
可以通过
reclaimPolicy
字段指定创建的Persistent Volume
的回收策略,回收策略包括:Delete
或者Retain
,没有指定默认为Delete
。2.3. Mount Options(挂载选项)
由 storage class 动态创建的 Persistent Volume 将使用 class 中
mountOptions
字段指定的挂载选项。2.4. 参数
Storage class 具有描述属于 storage class 卷的参数。取决于
分配器
,可以接受不同的参数。 当参数被省略时,会使用默认值。例如以下使用
Ceph RBD
kind: StorageClass apiVersion: storage.k8s.io/v3 metadata: name: fast provisioner: kubernetes.io/rbd parameters: monitors: 30.36.353.305:6789 adminId: kube adminSecretName: ceph-secret adminSecretNamespace: kube-system pool: kube userId: kube userSecretName: ceph-secret-user fsType: ext4 imageFormat: "2" imageFeatures: "layering"
对应的参数说明
-
monitors
:Ceph monitor,逗号分隔。该参数是必需的。 -
adminId
:Ceph 客户端 ID,用于在池(ceph pool)中创建映像。 默认是 “admin”。 -
adminSecretNamespace
:adminSecret 的 namespace。默认是 “default”。 -
adminSecret
:adminId 的 Secret 名称。该参数是必需的。 提供的 secret 必须有值为 “kubernetes.io/rbd” 的 type 参数。 -
pool
: Ceph RBD 池. 默认是 “rbd”。 -
userId
:Ceph 客户端 ID,用于映射 RBD 镜像(RBD image)。默认与 adminId 相同。 -
userSecretName
:用于映射 RBD 镜像的 userId 的 Ceph Secret 的名字。 它必须与 PVC 存在于相同的 namespace 中。该参数是必需的。 提供的 secret 必须具有值为 “kubernetes.io/rbd” 的 type 参数,例如以这样的方式创建:kubectl create secret generic ceph-secret --type="kubernetes.io/rbd" \ --from-literal=key='QVFEQ1pMdFhPUnQrSmhBQUFYaERWNHJsZ3BsMmNjcDR6RFZST0E9PQ==' \ --namespace=kube-system
-
fsType
:Kubernetes 支持的 fsType。默认:“ext4”。 -
imageFormat
:Ceph RBD 镜像格式,”1” 或者 “2”。默认值是 “1”。 -
imageFeatures
:这个参数是可选的,只能在你将 imageFormat 设置为 “2” 才使用。 目前支持的功能只是layering
。 默认是 ““,没有功能打开。
参考文章:
-
-
web Storage
2018-08-30 15:17:01HTML提供了一种新的对象...实际上我们将数据以键值对的形式保存到Storage对象里,通过Storage对象提供的方法进行数据操作。 增 Storage.setItem() 该方法接受一个键名和值作为参数,将会把键值对添加到存储...HTML5提供了一种新的存储机制。
HTML5提供了一种新的对象Storage,类似于String、Number、Object。通过Storage对象提供的方法和属性来对数据进行增删改查。
实际上我们将数据以键值对的形式保存到Storage对象里,通过Storage对象提供的方法进行数据操作。增
Storage.setItem()
该方法接受一个键名和值作为参数,将会把键值对添加到存储中,如果键名存在,则更新其对应的值。删
Storage.clear()
调用该方法会清空存储中的所有键名。
Storage.removeItem()
该方法接受一个键名作为参数,并把该键名从存储中删除。改
Storage.setItem()
该方法接受一个键名和值作为参数,将会把键值对添加到存储中,如果键名存在,则更新其对应的值。查
Storage.getItem()
该方法接受一个键名作为参数,返回键名对应的值。
Storage.key()
该方法接受一个数值 n 作为参数,并返回存储中索引为n 的键名
Storage.length
此属性为只读属性,返回存储的数据量
实际上我们并不需要去创建Storage实例,HTML5提供了两个Storage对象 localStorage和sessionStorage,这两个对象是Storage的实例,继承Storage的属性和方法。localStorage.__proto__===Storage.prototype //true sessionStorage.__proto__===Storage.prototype //true
两者唯一的区别就是:
sessionStorage数据值保存在会话期间,而localStorage会永久保存在本地(除非手动删除)。
注意:要访问同一个localStorage对象,页面必须来自同一域名
sessionStorage 和 localStorage 的用法基本一致,引用类型的值要转换成JSON -
storage事件
2018-03-16 15:06:56storage事件:当存储的storage数据发生变化时都会触发它,但是它不同于click类的事件会冒泡和能取消,storage改变的时候,触发这个事件会调用所有同域下其他窗口的storage事件,不过它本身触发storage即当前窗口是...storage事件:当存储的storage数据发生变化时都会触发它,但是它不同于click类的事件会冒泡和能取消,storage改变的时候,触发这个事件会调用所有同域下其他窗口的storage事件,不过它本身触发storage即当前窗口是不会触发这个事件的(当然ie这个特例除外,它包含自己本事也会触发storage事件)。
在使用 Storage 进行存取操作的同时,如果需要对存取操作进行监听,可以使用 HTML5 Web Storage api 内置的事件监听器对数据进行监控。只要 Storage 存储的数据有任何变动,Storage 监听器都能捕获。
interface Storage : Event{ readonly attribute DOMString key; readonly attribute DOMString? oldValue; readonly attribute DOMString? newValue; readonly attribute DOMString url; readonly attribute Storage? storageArea; void initStorageEvent(in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in DOMString keyArg, in DOMString oldValueArg, in DOMString newValueArg, in DOMString urlArg, in Storage storageAreaArg); };
不难看出其中包含以下属性:
- key 属性表示存储中的键名
- oldValue 属性表示数据更新前的键值,newValue 属性表示数据更新后的键值。如果数据为新添加的,则 oldValue 属性值为 null。如果数据通过 removeItem 被删除,则 newValue 属性值为 null 。如果 Storage 调用的是 clear 方法,则事件中的 key 、oldValue 、newValue 都是为 null
- url 属性记录 Storage 时间发生时的源地址
- StorageArea 属性指向事件监听对应的 Storage 对象
Storage 事件可以使用 W3C 标准的注册事件方法 addEventListenter 进行注册监听。例如:
window.addEventlistener("storage",showStorageEvent,false); function showStorageEvent(e){ console.log(e) }
举例:
页面a下,有个input框用来存储store,它自身绑定了storage事件,这个时候写入新的数据点击保存,这时新的sotre数据保存了,但是页面a的storage事件没触发,
而页面b下,绑定的storage事件则触发了。(ps:前提页面a和b在同域下,并都是打开状态不同窗口);
页面a代码:
12345678910111213141516171819202122232425<!
DOCTYPE
html>
<
html
>
<
head
>
<
meta
charset="utf-8">
<
title
></
title
>
</
head
>
<
body
>
<
input
type="text" placeholder="input date to save">
<
button
>save</
button
>
<
script
>
(function(D){
var val = D.getElementsByTagName("input")[0],
btn = D.getElementsByTagName("button")[0];
btn.onclick = function(){
var value = val.value;
if(!value) return;
localStorage.setItem("key", val.value);
};
window.addEventListener("storage", function(e){
console.log(e);
});
})(document);
</
script
>
</
body
>
</
html
>
页面b代码:
12345678910111213141516<!
DOCTYPE
html>
<
html
>
<
head
>
<
meta
charset="utf-8">
<
title
></
title
>
</
head
>
<
body
>
<
script
>
window.addEventListener("storage", function(e){
console.log(e);
document.write("oldValue: "+ e.oldValue + " newValue:" + e.newValue)
});
</
script
>
</
body
>
</
html
>
看到这里是不是很疑惑那storage事件到底有什么用,多窗口间多通信用到它就是最好选择了,比如某块公用内容区域基础数据部分都是从store中提取的,这个区域中大多数页面中都有,当用户打开多个页面时,在其中一个页面做了数据修改,那其他页面同步更新是不是很方便(当前页面就要用其他方式处理了),当然用于窗口间通信它作用不仅仅如此,更多的大家可以利用它特性去发挥。
在上面的demo页面b中storage的events对象的属性常用的如下:
oldValue:更新前的值。如果该键为新增加,则这个属性为null。
newValue:更新后的值。如果该键被删除,则这个属性为null。
url:原始触发storage事件的那个网页的网址。
key:存储store的key名;
-
MongoDB Storage
2016-09-12 10:07:55原文链接 On this page ...Storage Engine ... you mix storage engines in a replica set?WiredTiger Storage EngineMMAPv1 Storage EngineCan I manually pad documents to prevent moves原文链接
On this page
This document addresses common questions regarding MongoDB’s storage system.
Storage Engine Fundamentals
What is a storage engine?
A storage engine is the part of a database that is responsible for managing how data is stored, both in memory and on disk. Many databases support multiple storage engines, where different engines perform better for specific workloads. For example, one storage engine might offer better performance for read-heavy workloads, and another might support a higher-throughput for write operations.
SEE ALSO
Can you mix storage engines in a replica set?
Yes. You can have a replica set members that use different storage engines.
When designing these multi-storage engine deployments consider the following:
- the oplog on each member may need to be sized differently to account for differences in throughput between different storage engines.
- recovery from backups may become more complex if your backup captures data files from MongoDB: you may need to maintain backups for each storage engine.
WiredTiger Storage Engine
Can I upgrade an existing deployment to a WiredTiger?
Yes. See:
How much compression does WiredTiger provide?
The ratio of compressed data to uncompressed data depends on your data and the compression library used. By default, collection data in WiredTiger use Snappy block compression; zlib compression is also available. Index data use prefix compression by default.
To what size should I set the WiredTiger internal cache?
With WiredTiger, MongoDB utilizes both the WiredTiger internal cache and the filesystem cache.
Changed in version 3.2: Starting in MongoDB 3.2, the WiredTiger internal cache, by default, will use the larger of either:
- 60% of RAM minus 1 GB, or
- 1 GB.
For systems with up to 10 GB of RAM, the new default setting is less than or equal to the 3.0 default setting (For MongoDB 3.0, the WiredTiger internal cache uses either 1 GB or half of the installed physical RAM, whichever is larger).
For systems with more than 10 GB of RAM, the new default setting is greater than the 3.0 setting.
Via the filesystem cache, MongoDB automatically uses all free memory that is not used by the WiredTiger cache or by other processes. Data in the filesystem cache is compressed.
To adjust the size of the WiredTiger internal cache, seestorage.wiredTiger.engineConfig.cacheSizeGB and --wiredTigerCacheSizeGB. Avoid increasing the WiredTiger internal cache size above its default value.
NOTE
The storage.wiredTiger.engineConfig.cacheSizeGB limits the size of the WiredTiger internal cache. The operating system will use the available free memory for filesystem cache, which allows the compressed MongoDB data files to stay in memory. In addition, the operating system will use any free RAM to buffer file system blocks and file system cache.
To accommodate the additional consumers of RAM, you may have to decrease WiredTiger internal cache size.
The default WiredTiger internal cache size value assumes that there is a single mongod instance per machine. If a single machine contains multiple MongoDB instances, then you should decrease the setting to accommodate the other mongod instances.
If you run mongod in a container (e.g. lxc, cgroups, Docker, etc.) that does not have access to all of the RAM available in a system, you must set storage.wiredTiger.engineConfig.cacheSizeGB to a value less than the amount of RAM available in the container. The exact amount depends on the other processes running in the container.
To view statistics on the cache and eviction rate, see the wiredTiger.cache field returned from theserverStatus command.
How frequently does WiredTiger write to disk?
MongoDB configures WiredTiger to create checkpoints (i.e. write the snapshot data to disk) at intervals of 60 seconds or 2 gigabytes of journal data.
For journal data, MongoDB writes to disk according to the following intervals or condition:
-
New in version 3.2: Every 50 milliseconds.
-
MongoDB sets checkpoints to occur in WiredTiger on user data at an interval of 60 seconds or when 2 GB of journal data has been written, whichever occurs first.
-
If the write operation includes a write concern of j: true, WiredTiger forces a sync of the WiredTiger journal files.
-
Because MongoDB uses a journal file size limit of 100 MB, WiredTiger creates a new journal file approximately every 100 MB of data. When WiredTiger creates a new journal file, WiredTiger syncs the previous journal file.
MMAPv1 Storage Engine
What are memory mapped files?
A memory-mapped file is a file with data that the operating system places in memory by way of the mmap()system call. mmap() thus maps the file to a region of virtual memory. Memory-mapped files are the critical piece of the MMAPv1 storage engine in MongoDB. By using memory mapped files, MongoDB can treat the contents of its data files as if they were in memory. This provides MongoDB with an extremely fast and simple method for accessing and manipulating data.
How do memory mapped files work?
MongoDB uses memory mapped files for managing and interacting with all data.
Memory mapping assigns files to a block of virtual memory with a direct byte-for-byte correlation. MongoDB memory maps data files to memory as it accesses documents. Unaccessed data is not mapped to memory.
Once mapped, the relationship between file and memory allows MongoDB to interact with the data in the file as if it were memory.
How frequently does MMAPv1 write to disk?
In the default configuration for the MMAPv1 storage engine, MongoDB writes to the data files on disk every 60 seconds and writes to the journal files roughly every 100 milliseconds.
To change the interval for writing to the data files, use the storage.syncPeriodSecs setting. For the journal files, see storage.journal.commitIntervalMs setting.
These values represent the maximum amount of time between the completion of a write operation and when MongoDB writes to the data files or to the journal files. In many cases MongoDB and the operating system flush data to disk more frequently, so that the above values represents a theoretical maximum.
Why are the files in my data directory larger than the data in my database?
The data files in your data directory, which is the /data/db directory in default configurations, might be larger than the data set inserted into the database. Consider the following possible causes:
Preallocated data files
MongoDB preallocates its data files to avoid filesystem fragmentation, and because of this, the size of these files do not necessarily reflect the size of your data.
The storage.mmapv1.smallFiles option will reduce the size of these files, which may be useful if you have many small databases on disk.
The oplog
If this mongod is a member of a replica set, the data directory includes the oplog.rs file, which is a preallocated capped collection in the local database.
The default allocation is approximately 5% of disk space on 64-bit installations. In most cases, you should not need to resize the oplog. See Oplog Sizing for more information.
The journal
The data directory contains the journal files, which store write operations on disk before MongoDB applies them to databases. See Journaling.
Empty records
MongoDB maintains lists of empty records in data files as it deletes documents and collections. MongoDB can reuse this space, but will not, by default, return this space to the operating system.
To allow MongoDB to more effectively reuse the space, you can de-fragment your data. To de-fragment, use the compact command. The compact requires up to 2 gigabytes of extra disk space to run. Do not usecompact if you are critically low on disk space. For more information on its behavior and other considerations, see compact.
compact only removes fragmentation from MongoDB data files within a collection and does not return any disk space to the operating system. To return disk space to the operating system, see How do I reclaim disk space?.
How do I reclaim disk space?
The following provides some options to consider when reclaiming disk space.
NOTE
You do not need to reclaim disk space for MongoDB to reuse freed space. See Empty records for information on reuse of freed space.
repairDatabase
You can use repairDatabase on a database to rebuilds the database, de-fragmenting the associated storage in the process.
repairDatabase requires free disk space equal to the size of your current data set plus 2 gigabytes. If the volume that holds dbpath lacks sufficient space, you can mount a separate volume and use that for the repair. For additional information and considerations, see repairDatabase.
WARNING
Do not use repairDatabase if you are critically low on disk space.
repairDatabase will block all other operations and may take a long time to complete.
You can only run repairDatabase on a standalone mongod instance.
You can also run the repairDatabase operation for all databases on the server by restarting your mongodstandalone instance with the --repair and --repairpath options. All databases on the server will be unavailable during this operation.
Resync the Member of the Replica Set
For a secondary member of a replica set, you can perform a resync of the member by: stopping the secondary member to resync, deleting all data and subdirectories from the member’s data directory, and restarting.
For details, see Resync a Member of a Replica Set.
What is the working set?
Working set represents the total body of data that the application uses in the course of normal operation. Often this is a subset of the total data size, but the specific size of the working set depends on actual moment-to-moment use of the database.
If you run a query that requires MongoDB to scan every document in a collection, the working set will expand to include every document. Depending on physical memory size, this may cause documents in the working set to “page out,” or to be removed from physical memory by the operating system. The next time MongoDB needs to access these documents, MongoDB may incur a hard page fault.
For best performance, the majority of your active set should fit in RAM.
What are page faults?
With the MMAPv1 storage engine, page faults can occur as MongoDB reads from or writes data to parts of its data files that are not currently located in physical memory. In contrast, operating system page faults happen when physical memory is exhausted and pages of physical memory are swapped to disk.
If there is free memory, then the operating system can find the page on disk and load it to memory directly. However, if there is no free memory, the operating system must:
- find a page in memory that is stale or no longer needed, and write the page to disk.
- read the requested page from disk and load it into memory.
This process, on an active system, can take a long time, particularly in comparison to reading a page that is already in memory.
See Page Faults for more information.
What is the difference between soft and hard page faults?
Page faults occur when MongoDB, with the MMAP storage engine, needs access to data that isn’t currently in active memory. A “hard” page fault refers to situations when MongoDB must access a disk to access the data. A “soft” page fault, by contrast, merely moves memory pages from one list to another, such as from an operating system file cache.
See Page Faults for more information.
Can I manually pad documents to prevent moves during updates?
Changed in version 3.0.0.
With the MMAPv1 storage engine, an update can cause a document to move on disk if the document grows in size. To minimize document movements, MongoDB uses padding.
You should not have to pad manually because by default, MongoDB uses Power of 2 Sized Allocations to add padding automatically. The Power of 2 Sized Allocations ensures that MongoDB allocates document space in sizes that are powers of 2, which helps ensure that MongoDB can efficiently reuse free space created by document deletion or relocation as well as reduce the occurrences of reallocations in many cases.
However, if you must pad a document manually, you can add a temporary field to the document and then$unset the field, as in the following example.
WARNING
Do not manually pad documents in a capped collection. Applying manual padding to a document in a capped collection can break replication. Also, the padding is not preserved if you re-sync the MongoDB instance.
var myTempPadding = [ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]; db.myCollection.insert( { _id: 5, paddingField: myTempPadding } ); db.myCollection.update( { _id: 5 }, { $unset: { paddingField: "" } } ) db.myCollection.update( { _id: 5 }, { $set: { realField: "Some text that I might have needed padding for" } } )
SEE ALSO
Data Storage Diagnostics
How can I check the size of a collection?
To view the statistics for a collection, including the data size, use the db.collection.stats() method from the mongo shell. The following example issues db.collection.stats() for the orders collection:
db.orders.stats();
MongoDB also provides the following methods to return specific sizes for the collection:
- db.collection.dataSize() to return data size in bytes for the collection.
- db.collection.storageSize() to return allocation size in bytes, including unused space.
- db.collection.totalSize() to return the data size plus the index size in bytes.
- db.collection.totalIndexSize() to return the index size in bytes.
The following script prints the statistics for each database:
db._adminCommand("listDatabases").databases.forEach(function (d) { mdb = db.getSiblingDB(d.name); printjson(mdb.stats()); })
The following script prints the statistics for each collection in each database:
db._adminCommand("listDatabases").databases.forEach(function (d) { mdb = db.getSiblingDB(d.name); mdb.getCollectionNames().forEach(function(c) { s = mdb[c].stats(); printjson(s); }) })
How can I check the size of indexes for a collection?
To view the size of the data allocated for an index, use the db.collection.stats() method and check the indexSizes field in the returned document.
How can I get information on the storage use of a database?
The db.stats() method in the mongo shell returns the current state of the “active” database. For the description of the returned fields, see dbStats Output.
-
The Storage Situation: External Storage
2015-10-16 10:37:25External Storage -
prometheus之Local storage和remote storage
2019-03-30 17:27:35而PrometheUS默认是本地存储在tsdb上,如果考虑存储大量的sample,可以考虑remote storage。 Local storage 简述 本地存储的最小单位是block,每个block是最近两个小时的数据。block里面是多个chunk。chu... -
Web Storage
2016-10-09 09:52:58Web Storage 分为本地存储和会话存储,不能跨域访问。 Web Storage 使在不影响网站性能的情况下存储大量数据成为可能。 注意:Web Storage 存储的是字符串,获取和存储时别忘了用 JSON.stringify() 和 JSON.parse... -
android Internal storage 和External storage
2015-07-29 14:54:20android Internal storage 和External storage: android 删除文件 保存到Internal Storage --->保密性文件的位置 -
storage存储
2019-04-12 18:15:20storage只在本地,不参与网络传输,存储的都是字符串 localstorage/seesionstorage 存储/取出数据: localstorage.name = "tanjw"//可以利用json的方法将对象转为字符串,方便存取使用。 localstorage.name //就... -
网站开发进阶(三十)HTML5--本地存储Web Storage
2016-01-27 09:14:37WebStorage功能,顾名思义,就是在Web上针对客户端本地储存数据的功能,具体来说WebStorage分为两种; sessionStorage: 将数据保存在session对象中,所谓session是指用户在浏览某个网站时,从进入网站到浏览器... -
SLAM Mesh storage processing
2019-12-14 12:37:40Mesh storage processing Project Language License 3DTK C++ GPLv3 CGAL C++ Module dependent GPL/LGPL InstantMesh Mesh Simplification C++ BSD License GEOGRAM C++ Revised BSD License libig... -
Azure File Storage 基本用法 -- Azure Storage 之 File
2016-10-25 11:44:31Azure Storage 是微软 Azure 云提供的云端存储解决方案,当前支持的存储类型有 Blob、Queue、File 和 Table。笔者在《Azure Blob Storage 基本用法》中介绍了 Blob Storage 的基本用法,本文将介绍 File Storage 的... -
Azure Queue Storage 基本用法 -- Azure Storage 之 Queue
2016-11-01 11:47:01ure Storage 是微软 Azure 云提供的云端存储解决方案,当前支持的存储类型有 Blob、Queue、File 和 Table。笔者在《Azure File Storage 基本用法》中介绍了 File Storage 的基本用法,本文将介绍 Queue Storage 的... -
Webstorage特性
2017-10-30 23:53:24Webstorage -
IBM System Storage DS Storage Manager 安装和支持指南
2010-07-13 09:35:56IBM System Storage DS Storage Manager 安装和支持指南 -
Azure Blob Storage 基本用法 -- Azure Storage 之 Blob
2016-10-18 14:22:08Azure Storage 是微软 Azure 云提供的云端存储解决方案,当前支持的存储类型有 Blob、Queue、File 和 Table。笔者在前文中介绍了Table Storage 的基本用法,本文将通过C# 代码介绍Blob Storage的主要使用方法。 -
JS 监听 storage
2019-02-14 15:48:49在同一页面添加监听事件监听 storage 并不起作用,需要重写操作 storage 的方法,所以有以下两种方法用来监听。 监听同源页面中 storage 的变动 storage.html &amp;amp;amp;amp;amp;amp;amp;amp;lt;!... -
IBM SVC storage
2015-07-07 20:48:37IBM SVC storage 1. Introduction TheIBM SAN Volume Controller (SVC) is a block storage virtualization appliancethat belongs to the IBM System Storage product family. SVC implements anind -
SAP WM 为Storage Type启用SUM后要为Storage Unit Type指派Storage Bin Type
2015-10-29 20:56:48SAP WM 为Storage Type启用SUM后要为Storage Unit Type指派Storage Bin Type ... -
Proxmox VE storage
2019-09-15 20:11:03The Proxmox VE storage model is very flexible. Virtual machine images can either be stored on one or several local storages, or on shared storage like NFS or iSCSI (NAS, SAN). There are no limits, and... -
lotus storage 存储过程
2019-12-25 13:59:27lotus storage 存储过程1,lotus storage 存储过程 1,lotus storage 存储过程 参考: filecoin-project/lotus/storage/sectors.go -
ionic2 storage
2017-03-05 19:25:13AngularJS2 Storage -
web storage详解,web storage和cookie的区别
2018-01-05 16:21:03web storage介绍 web storage和Cookie都是用来在客户端存储数据。 web storage又分为localStrage和sessionStorage Cookie的弊端 每次请求时,cookie都会存放在请求头中。 请求被拦截,cookie数据会存在安全... -
ionic中storage使用
2019-01-27 21:48:11storage使用 1.引入import { Storage } from ‘@ionic/storage’;2.注入constructor(public storage: Storage) {}3.存储this.storage.set(‘PROJECTINFO’, JSON.stringify(this.projectList));4.取this.storage.get... -
Oracle: truncate table 的drop storage和reuse storage
2018-12-10 10:16:161.Truncate drop storage行为 Truncate数据表默认行为包括了drop storage参数。 数据所在的extent空间被释放,剩下第一个extent,释放的空间可以供其它segment使用; test表中的index:数据删除,剩下第一个extent;... -
jest mock storage
2018-09-21 09:39:13同一个文件中的tests是串行执行的 用toHaveBeenCalledTimes断言调用构造...const userStorage = new UserStorage() export function* loginHookSaga() {} export function* logoutHookSaga() {} export function* r... -
Storage Metrics
2015-05-18 17:05:18SharePoint站点在使用过程中,内容会越来越过,这会导致占用内容数据库,也会增加管理的复杂度,甚至会降低系统的响应时间。可以通过设定site quota来...而SharePoint提供的Storage Metrics 功能对管理员就很有帮助了。 -
HTML5 Web Storage事件
2018-04-27 22:12:01Storage事件在某些复杂情况下,如果多个页面都需要访问本地存储的数据,就需要在存储区域的内容发生改变时,能够通知相关的页面。Web Storage API内建了一套事件通知机制,当存储区域的内容发生改变(包括增加、修改... -
kubernetes进阶之路(十六)~~~Storage系列之StorageClass
2020-01-06 18:57:271 StorageClass 一般情况下,我们不会去手动管理PV,我们会采用自动创建的方式来实现,先来了解一下StorageClass。 官网:https://kubernetes.io/docs/concepts/storage/storage-classes/ nfs github:github:...
-
python数据分析基础
-
2020牛客暑期多校集训营第三场题解.pdf
-
WPF上位机数据采集与监控系统零基础实战
-
初中数学竞赛专家讲座初等数论-2021.01.15.pdf
-
我的Git笔记.pdf
-
Cocos Creator游戏开发-连连看 (接入腾讯优量汇广告)
-
麦森数(C++)
-
jdk-7u191-linux-x64.tar.gz.zip
-
jdk-8u161-linux-x64.zip
-
基于 C# 的 GIS 近海环境管理系统
-
【2021】UI自动化测试框架(Selenium3)
-
华为Mate10保时捷维修图PCB位置图(PDF格式)
-
关于如何对Array对象使用动态属性名称
-
Centos 如何安装 nginx
-
大数据Hive on MR/TEZ与hadoop的整合应用
-
大学生职业生涯规划书.docx
-
小论文数据求解.zip
-
SubstancePainter插件开发-基础入门
-
Vue中如何实现代码高亮功能?
-
API代理版自动发卡平台源码V4.5.6.zip