云计算课设(一)

云计算课程设计(docker实现) 云计算课程设计(docker实现) import docker import subprocess import tkinter import tkinter.messagebox import random import paramiko import tkinter.font as tkFont from PIL import Image, ImageTk from tkinter import ttk import os host_share = '/mpi_config/' docker_fil 阅读详情

可视化窗口、容错机制

import docker
import sys
import tkinter
import tkinter.messagebox
import random
import paramiko
import tkinter.font as tkFont
from PIL import Image, ImageTk
from tkinter import ttk
import os
import re
import datetime
import threading
import time
import subprocess

host_share = '/mpi_config/'
docker_file = '/mpi_config'
volumes = {}
temp_volumes = {}
temp_volumes['bind'] = docker_file
temp_volumes['mode'] = 'rw'
volumes[host_share] = temp_volumes


ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(hostname="192.168.43.122", port=22, username="ares", password="123456")

ip1 = '192.168.43.237'
ip2 = '192.168.43.122'
docker_images = '06ab69e711f4'
connect1 = ip1 + ':2375'
connect2 = ip2 + ':2375'

client1 = docker.DockerClient(base_url=connect1,use_ssh_client=True)
client2 = docker.DockerClient(base_url=connect2,use_ssh_client=True)
network = client1.networks.get('multihost')
CPU_yang = 4
CPU_zhang = 4


def write_config():
    file_address = host_share + '/mpi_config'
    containers1 = client1.containers.list()
    containers2 = client2.containers.list()
    containers_ip = network.attrs['Containers']
    print(containers2)
    print(containers1)
    print(containers_ip)
    print(network)
    ips = []
    with open(file_address, mode='w', encoding='utf-8') as file_obj:
        for container in containers1:
            # stats = container.stats(decode=True)
            # stats_value = next(stats)
            # pids_num = stats_value['pids_stats']['current']
            for container_ip in containers_ip:
                key = container_ip
                value = containers_ip[key]
                if value['Name'] == container.name:
                    ip = value['IPv4Address'][:-3]
                    if value['Name'] == 'master_yang':
                        file_obj.write(ip + ':' + str(1) + '\n')
                    else:
                        ips.append(ip)
        for container in containers2:
            # stats = container.stats(decode=True)
            # stats_value = next(stats)
            # pids_num = stats_value['pids_stats']['current']
            for container_ip in containers_ip:
                key = container_ip
                value = containers_ip[key]
                if value['Name'] == container.name:
                    ip = value['IPv4Address'][:-3]
                    if value['Name'] == 'master_zhang':
                        file_obj.write(ip + ':' + str(1) + '\n')
                    else:
                        ips.append(ip)
        for i in range(len(ips)):
            file_obj.write(ips[i] + ':' + str(1) + '\n')
    print(ips)


def create():
    create_one = tkinter.Toplevel()
    frame_main = tkinter.Frame(create_one, bg="whitesmoke")
    frame_main.propagate(False)
    frame_main.pack(expand=tkinter.YES, fill=tkinter.BOTH)
    create_one.title('创建虚拟机')
    create_one.geometry('800x600')  # 窗体大小
    global memory, CPU_number, docker_name, docker_place

    number3 = tkinter.StringVar()
    memory = ttk.Combobox(create_one, width=12, textvariable=number3)
    memory['values'] = ('1', '2', '3', '4', '5', '6', '7', '8')
    memory.place(width=250, x=500, y=20, height=20)
    memory.current(0)
    memory_label = tkinter.Label(create_one, text='请输入最大内存(单位GB)(范围1-8)',bg='whitesmoke')
    memory_label.place(x=20, y=20, width=400, height=20)

    number1 = tkinter.StringVar()
    CPU_number = ttk.Combobox(create_one, width=12, textvariable=number1)
    CPU_number['values'] = ('0')
    CPU_number.place(width=250, x=500, y=70, height=20)
    CPU_number.current(0)
    CPU_number_label = tkinter.Label(create_one, text='请输入CPU核数目',bg='whitesmoke')
    CPU_number_label.place(x=20, y=70, width=400, height=20)

    docker_name = tkinter.Entry(create_one)
    docker_name.place(width=250, x=500, y=120, height=20)
    docker_name_label = tkinter.Label(create_one, text='请输入虚拟机名字', width=80,bg='whitesmoke')
    docker_name_label.place(x=20, y=120, width=400, height=20)

    number2 = tkinter.StringVar()
    docker_place = ttk.Combobox(create_one, width=12, textvariable=number2)
    docker_place['values'] = ('0', '1')
    docker_place.place(width=250, x=500, y=170, height=20)
    docker_place.current(0)
    docker_place_label = tkinter.Label(create_one, text='请选择在那一台物理机上创建docker(0在杨嘉禧主机, 1在张铭宇主机):',bg='whitesmoke')
    docker_place_label.place(x=20, y=170, width=400, height=20)

    button2 = tkinter.Button(create_one, text='创建虚拟机', command=docker_create, font=('Arial', 12), width=50, height=2)
    button2.place(x=170, y=300)


def docker_check_status(container, flag):
    result = {}
    result['name'] = container.name
    containers_ip = network.attrs['Containers']
    ip = '----'
    result['ipv4'] = ip
    for container_ip in containers_ip:
        key = container_ip
        value = containers_ip[key]
        if value['Name'] == container.name:
            ip = value['IPv4Address'][:-3]
            result['ipv4'] = ip
            break

    stats = container.stats(decode=True)
    stats_value = next(stats)
    short_id = container.short_id
    status = container.status
    result['status'] = status
    result['id'] = short_id
    # view_time = stats_value['read'][:-11]
    # view_time = view_time[0:11] + str((int(view_time[11:13]) + 8) % 24) + view_time[13:]
    # result['view_time'] = view_time
    try:
        pids_num = stats_value['pids_stats']['current']
    except:
        pids_num = 0
    result['pid_num'] = pids_num
    if flag == 0:
        out = subprocess.Popen('docker stats {}'.format(container.name), shell=True, stdout=subprocess.PIPE)
        for n, v in enumerate(out.stdout):
            if n == 1:
                value = bytes.decode(v.strip()).split(' ')
                valuelist = [j for j in value if j != '' and j != '/']
                result['cpu_percentage'] = valuelist[2]
                result['memory_use'] = valuelist[3]
                result['memory_total'] = valuelist[4]
                result['memory_percentage'] = valuelist[5]
                out.terminate()
                break
    if flag == 1:
        command = "docker stats --no-stream " + container.name
        stdin, stdout, stderr = ssh.exec_command(command)
        a = (stdout.read().decode()).split('\n')[1]
        b = a.split(' ')
        list1 = []
        for i in range(len(b)):
            if len(b[i]) > 1:
                list1.append(b[i])
        result['cpu_percentage'] = list1[2]
        result['memory_use'] = list1[3]
        result['memory_total'] = list1[4]
        result['memory_percentage'] = list1[5]

    return result


def check():
    create_two = tkinter.Toplevel()
    frame_main = tkinter.Frame(create_two, bg="whitesmoke")
    frame_main.propagate(False)
    frame_main.pack(expand=tkinter.YES, fill=tkinter.BOTH)
    create_two.title('查看虚拟机状态')
    create_two.geometry('1100x700')  # 窗体大小
    write_config()
    cmd = 'tar czf - /mpi_config/mpi_config | ssh hadoop@'+'192.168.43.237'+' tar xzf - -C /'
    os.system(cmd)
    containers1 = client1.containers.list(all=True)
    result1 = {}
    for container in containers1:
        result1[container.name] = docker_check_status(container, 0)
    containers2 = client2.containers.list(all=True)
    result2 = {}
    for container in containers2:
        result2[container.name] = docker_check_status(container, 1)

    label1 = tkinter.Label(create_two, text='机器yang', font=('Arial', 15),bg="whitesmoke")
    label1.place(x=500, y=0, width=100, height=50)
    for i, k in enumerate(result1):
        data = result1[k]
        label = tkinter.Label(create_two, font=tkFont.Font(family="微软雅黑", size=10),bg="whitesmoke",text='name:{}   status:{}   ip:{}   pid_num:{}   cpu_percentage:{}   memory_use:{}   memory_total:{}   memory_percentage:{}'.format(data['name'], data['status'], data['ipv4'], data['pid_num'], data['cpu_percentage'], data['memory_use'], data['memory_total'], data['memory_percentage']))
        label.place(x=0, y=i*45+70, height=30)
    label2 = tkinter.Label(create_two, text='机器zhang', font=('Arial', 15),bg="whitesmoke")
    label2.place(x=500, y=320, width=100, height=50)
    for i, k in enumerate(result2):
        data = result2[k]
        label = tkinter.Label(create_two, font=tkFont.Font(family="微软雅黑", size=10),bg="whitesmoke",text='name:{}   status:{}   ip:{}   pid_num:{}   cpu_percentage:{}   memory_use:{}   memory_total:{}   memory_percentage:{}'.format(data['name'], data['status'], data['ipv4'], data['pid_num'], data['cpu_percentage'], data['memory_use'], data['memory_total'], data['memory_percentage']))
        label.place(x=0, y=i*45+390, height=30)


def start():
    create_three = tkinter.Toplevel()
    frame_main = tkinter.Frame(create_three, bg="whitesmoke")
    frame_main.propagate(False)
    frame_main.pack(expand=tkinter.YES, fill=tkinter.BOTH)
    create_three.title('开启虚拟机')
    create_three.geometry('800x600')  # 窗体大小
    global name2, docker_place2

    number2 = tkinter.StringVar()
    name2 = ttk.Combobox(create_three, width=12, textvariable=number2)
    containers1 = client1.containers.list(all=True)
    containers2 = client2.containers.list(all=True)
    containers1_run = client1.containers.list()
    containers2_run = client2.containers.list()
    list_temp = []
    for container in containers1:
        if container not in containers1_run:
            list_temp.append(container.name)
    for container in containers2:
        if container not in containers2_run:
            list_temp.append(container.name)
    if len(list_temp) == 0:
        list_temp.append('所有的docker容器都已经开启')
    name2['values'] = tuple(list_temp)
    name2.place(width=250, x=500, y=70, height=20)
    name2.current(0)
    # name2 = tkinter.Entry(create_three)
    # name2.place(width=250, x=500, y=70, height=20)
    name2_label = tkinter.Label(create_three, text='请输入要开启的虚拟机名字',bg='whitesmoke')
    name2_label.place(x=20, y=70, width=400, height=20)

    number1 = tkinter.StringVar()
    docker_place2 = ttk.Combobox(create_three, width=12, textvariable=number1)
    docker_place2['values'] = ('0', '1')
    docker_place2.place(width=250, x=500, y=170, height=20)
    docker_place2.current(0)
    docker_place2_label1 = tkinter.Label(create_three, text='请选择在那一台物理机上开启docker(0在杨嘉主机, 1在张铭宇主机):',bg='whitesmoke')
    docker_place2_label1.place(x=20, y=170, width=400, height=20)

    button1 = tkinter.Button(create_three, text='开启虚拟机', command=start_container, font=('Arial', 12), width=50,
                             height=2)
    button1.place(x=170, y=300)


def remove():
    create_four = tkinter.Toplevel()
    frame_main = tkinter.Frame(create_four, bg="whitesmoke")
    frame_main.propagate(False)
    frame_main.pack(expand=tkinter.YES, fill=tkinter.BOTH)
    create_four.title('删除虚拟机')
    create_four.geometry('800x600')  # 窗体大小
    global name1, docker_place1

    number1 = tkinter.StringVar()
    name1 = ttk.Combobox(create_four, width=12, textvariable=number1)
    containers1 = client1.containers.list(all=True)
    containers2 = client2.containers.list(all=True)
    list_temp = []
    for container in containers1:
        list_temp.append(container.name)
    for container in containers2:
        list_temp.append(container.name)
    name1['values'] = tuple(list_temp)
    name1.place(width=250, x=500, y=70, height=20)
    name1.current(0)
    name1_label = tkinter.Label(create_four, text='请输入要删除的虚拟机名字',bg='whitesmoke')
    name1_label.place(x=20, y=70, width=400, height=20)

    number2 = tkinter.StringVar()
    docker_place1 = ttk.Combobox(create_four, width=12, textvariable=number2)
    docker_place1['values'] = ('0', '1')
    docker_place1.place(width=250, x=500, y=170, height=20)
    docker_place1.current(0)
    docker_place_label1 = tkinter.Label(create_four, text='请选择在那一台物理机上删除docker(0在杨嘉禧主机, 1在张铭宇主机):',bg='whitesmoke')
    docker_place_label1.place(x=20, y=170, width=400, height=20)

    button1 = tkinter.Button(create_four, text='删除虚拟机', command=remove_container, font=('Arial', 12), width=50, height=2)
    button1.place(x=170, y=300)


def stop():
    create_five = tkinter.Toplevel()
    frame_main = tkinter.Frame(create_five, bg="whitesmoke")
    frame_main.propagate(False)
    frame_main.pack(expand=tkinter.YES, fill=tkinter.BOTH)
    create_five.title('停止虚拟机')
    create_five.geometry('800x600')  # 窗体大小
    global name3, docker_place3

    number1 = tkinter.StringVar()
    name3 = ttk.Combobox(create_five, width=12, textvariable=number1)
    containers1 = client1.containers.list()
    containers2 = client2.containers.list()
    list_temp = []
    for container in containers1:
        list_temp.append(container.name)
    for container in containers2:
        list_temp.append(container.name)
    name3['values'] = tuple(list_temp)
    name3.place(width=250, x=500, y=70, height=20)
    name3.current(0)
    name3_label = tkinter.Label(create_five, text='请输入要停止的虚拟机名字',bg='whitesmoke')
    name3_label.place(x=20, y=70, width=400, height=20)

    number2 = tkinter.StringVar()
    docker_place3 = ttk.Combobox(create_five, width=12, textvariable=number2)
    docker_place3['values'] = ('0', '1')
    docker_place3.place(width=250, x=500, y=170, height=20)
    docker_place3.current(0)
    docker_place_label3 = tkinter.Label(create_five, text='请选择在哪一台物理机上停止docker(0在杨嘉禧主机, 1在张铭宇主机):',bg='whitesmoke')
    docker_place_label3.place(x=20, y=170, width=400, height=20)

    button3 = tkinter.Button(create_five, text='停止虚拟机', command=stop_container, font=('Arial', 12), width=50, height=2)
    button3.place(x=170, y=300)


def remove_container():
    position = docker_place1.get()
    name = name1.get()
    if position == "0":
        client = client1
    elif position == '1':
        client = client2
    if position!='0' and position!='1':
        tkinter.messagebox.showwarning("提示", '虚拟机参数输入错误')
        return
    name_list = []
    containers = client.containers.list(all=True)
    for container in containers:
        name_list.append(container.name)
    if name not in name_list:
        tkinter.messagebox.showwarning("提示", '要删除的虚拟机不存在')
        return
    container = client.containers.get(name)
    container.stop()
    container.remove()
    tkinter.messagebox.showwarning("提示", '成功删除虚拟机')


def start_container():
    position = docker_place2.get()
    name = name2.get()
    if position == "0":
        client = client1
    elif position == '1':
        client = client2
    if position != '0' and position != '1':
        tkinter.messagebox.showwarning("提示", '虚拟机参数输入错误')
        return
    name_list = []
    containers = client.containers.list(all = True)
    for container in containers:
        name_list.append(container.name)
    if name not in name_list:
        tkinter.messagebox.showwarning("提示", '要开启的虚拟机不存在')
        return
    container = client.containers.get(name)
    container.start()
    container.exec_run('/etc/init.d/ssh start')
    tkinter.messagebox.showwarning("提示", '成功开启虚拟机')


def stop_container():
    position = docker_place3.get()
    name = name3.get()
    if position == "0":
        client = client1
    elif position == '1':
        client = client2
    if position != '0' and position != '1':
        tkinter.messagebox.showwarning("提示", '虚拟机参数输入错误')
        return
    name_list = []
    containers = client.containers.list()
    for container in containers:
        name_list.append(container.name)
    if name not in name_list:
        tkinter.messagebox.showwarning("提示", '要停止的虚拟机不存在')
        return
    container = client.containers.get(name)
    container.stop()
    tkinter.messagebox.showwarning("提示", '成功停止虚拟机')



def docker_create():
    position = docker_place.get()
    if position == "0":
        client = client1
        CPU_number_limit = CPU_yang
    elif position == '1':
        client = client2
        CPU_number_limit = CPU_zhang
    if position!= '0' and position!='1':
        tkinter.messagebox.showwarning("提示", '虚拟机参数输入错误')
        return
    name = docker_name.get()
    memory_number = int(eval(memory.get()))
    if memory_number>8:
        tkinter.messagebox.showwarning("提示", '虚拟机超过主机最大内存容量')
        return
    mem_limit = memory.get() + 'g'
    number = int(eval(CPU_number.get()))
    if number>CPU_number_limit:
        tkinter.messagebox.showwarning("提示", '虚拟机超过最大CPU核数目')
        return
    CPU_list = []
    CPU_str = ''
    while len(CPU_list) < number:
        i = random.randint(0,7)
        if i not in CPU_list:
            CPU_list.append(i)
            CPU_str += str(i)
            CPU_str += ','
    CPU_str = CPU_str[:-1]
    container1 = client.containers.run(image=docker_images, name=name, mem_limit=mem_limit, tty=True, privileged=True, detach=True,stdin_open=True,network='multihost',cpuset_cpus=CPU_str, volumes =volumes)
    container1.exec_run('/etc/init.d/ssh start')
    tkinter.messagebox.showwarning("提示", '虚拟机创建成功')
    client1.close()
    client2.close()

# write_config()
def run(): # 定时器回调
    global timer
    ping = os.popen('ping 192.168.43.122 -c 1').read()
    if 'Destination Host Unreachable' in ping:
        # print(ping)
        print('访问失败')
        tkinter.messagebox.showwarning("提示", '主机连接出现错误')
        sys.exit(0)
    else:
        print('访问成功')
    timer = threading.Timer(2, run)
    timer.start()

timer = threading.Timer(2,run) # 1代表1秒后执行
timer.start()  # 启动定时器

time.sleep(3)   ## 等待6s
print('====')
time.sleep(3)   ## 等待6s
print('====')
time.sleep(3)   ## 等待6s
print('====')
root = tkinter.Tk()
root.title('docker虚拟管理')  # 标题
root.geometry('800x700')  #窗体大小

frame_top = tkinter.Frame(root, bg="grey")
frame_top.pack(fill=tkinter.X)


lbl_image = tkinter.Label(frame_top, width=100, height=80)
lbl_image.pack(side=tkinter.LEFT)
imgtop = Image.open(r'docker.jpg')
img1 = imgtop.resize((100, 80), Image.ANTIALIAS)
tk_img = ImageTk.PhotoImage(img1)
lbl_image.image = tk_img
lbl_image.config(image=tk_img)


tkinter.Label(frame_top, text="制作成员:张铭宇 杨嘉禧",bg = 'Green',font=tkFont.Font(family="微软雅黑", size=12, weight=tkFont.NORMAL)).pack(side=tkinter.LEFT, padx=20)
tkinter.Label(frame_top, text="云计算课程设计", bg="Green", height=2, font=tkFont.Font(family="微软雅黑", size=12, weight=tkFont.NORMAL)).pack(side=tkinter.RIGHT, padx=100)


frame_main = tkinter.Frame(root, bg="whitesmoke")
frame_main.propagate(False)
frame_main.pack(expand=tkinter.YES, fill=tkinter.BOTH)

frame_maintop = tkinter.Frame(frame_main, bg="white", height=40)
frame_maintop.pack(fill=tkinter.X, padx=20, pady=10)
imagetop = tkinter.Label(frame_maintop, width=180, height=40)
tkinter.Label(frame_maintop, text="虚拟机管理器", bg="white", fg='black', height=2, font=tkFont.Font(family="微软雅黑", size=19, weight=tkFont.BOLD)).pack(side=tkinter.LEFT, padx=300)

frame_mainleft=tkinter.Frame(frame_main, width=800, bg="white")
frame_mainleft.pack(side=tkinter.RIGHT, fill=tkinter.Y, padx=30)
tkinter.Label(frame_mainleft, text="  主要功能", bg="white", fg='black', height=2, font=tkFont.Font(family="微软雅黑", size=18,weight=tkFont.BOLD)).pack(anchor=tkinter.W, padx=300, pady=5)
frame_mainleft.propagate(False)
button1 = tkinter.Button(frame_mainleft, text='创建虚拟机', command=create, font=tkFont.Font(family="微软雅黑", size=11), width=50, height=2, bg='white').pack(padx=10,pady=5)
button2 = tkinter.Button(frame_mainleft, text='查看虚拟机状态', command=check, font=tkFont.Font(family="微软雅黑", size=11), width=50, height=2, bg='white').pack(padx=10,pady=5)
button3 = tkinter.Button(frame_mainleft, text='开启虚拟机', command=start, font=tkFont.Font(family="微软雅黑", size=11), width=50, height=2, bg='white').pack(padx=10,pady=5)
button5 = tkinter.Button(frame_mainleft, text='停止虚拟机', command=stop, font=tkFont.Font(family="微软雅黑", size=11), width=50, height=2, bg='white').pack(padx=10,pady=5)
button4 = tkinter.Button(frame_mainleft, text='删除虚拟机', command=remove, font=tkFont.Font(family="微软雅黑", size=11), width=50, height=2, bg='white').pack(padx=10,pady=5)


root.mainloop()
ssh.close()

华中科技大学计算机学院云计算与虚拟化课程结课报告 内存虚拟化一般分为基于软件的内存虚拟化和硬件辅助的内存虚拟化,其中,常用的基于软件的内存虚拟化技术为“影子页表”技术,硬件辅助内存虚拟化技术为Intel的EPT(Extend Page Table,扩展页表)技术。本文分析了最先进的嵌套虚拟化方法,虽然硬件虚拟化支持(如 Intel VT-x 和 AMD-V )与基于软件的单级虚拟化仿真相比提供了卓越的性能和更低的开销,但在二级嵌套虚拟化中,它可能会导致次优性能和主机虚拟机管理程序(最特权级别)的过度陷阱。3、复现文章中的技术或者其他和云计算相关的实践。 阅读详情

相关推荐

一图了解云计算

云计算历史 云计算现状 云计算定义 云计算(Cloud Computing)的一个核心理念就是通过不断提高“云”的处理能力,进而减少用户终端的处理负担,最终使用户终端简化成一个单纯的输入输出设备,并能按需享受“云”的强大计算处理能力。 云计算(Cloud Computing)的核心思想,是将大量用网络连接的计算资源统一管理和调度,构成一个计算资源池向用户按需服务。 何为云计算 云计算优势 超大规模、虚拟化、高可用、按需服务、极其廉价 云计算好处 云计算未来 ...

码农洞见 6879

云计算平台构建与实验设计

课程设计任务书 一、作业目的 物联网的核心是应用,应用的核心是云计算。通过构建一个云计算平台,并利用这个平台设计云计算实验,将结果与普通的电脑计算比较两者的差别,感受云计算的优越性能,从而对物联网有更深刻的体验与认识。 二、作业内容及要求 能够按照课程设计任务书按照相应的要求完成整个云计算平台的搭建,要完成这个任务,就要对云计算平台的架构和原理有一定的认识,对物

照玄 3万+

hadoop 分布式云计算 课程设计报告

这个是我 课程设计的报告 大神们想要的自己下载吧 。 。。 呵呵

《云计算与大数据技术应用》

《第一章》云计算概述 1.1什么是云计算? 1.1.1云计算的定义 云计算是分布式计算的一种,指的是通过网络“云”将巨大的数据计算处理程序分解成无数个小程序,然后,通过多部服务器组成的系统进行处理和分析这些小程序得到结果并返回给用户。云计算早期,简单地说,就是简单的分布式计算,解决任务分发,并进行计算结果的合并。因而,云计算又称为网格计算。通过这项技术,可以在很短的时间内(几秒钟)完成对数以万计的数据的处理...

m0_64366382的博客 1万+

云计算技术与应用课程设计

要解决的应用领域问题、关键技术、如何利用云计算或物联网相关技术解决、解决方案的逻辑框架、应用系统的软硬件结构等;文字描述和结构图并用,内容完整、条理清晰,表述清楚、语言流畅、图文并茂

广工云计算课程报告

这是一篇讨论桌面虚拟化的实现和作用的广工云计算课程报告

2024年末 云计算课设(从虚拟机到docker到k8s部署)

后续待补充,有问题随时联系,亲测无误。

2201_75609800的博客 232

云计算课设

实验概述 本实验将向您介绍启动、管理和监控 Amazon EC2 实例以及调整其大小的基本概述。 什么是 Amazon Elastic Compute Cloud (Amazon EC2)? Amazon EC2 是一种 Web 服务,可在云中提供可调计算容量。该服务旨在让开发人员能更轻松地进行 Web 级的云计算。 Amazon EC2 的 Web 服务接口非常简单,您可以轻松获取和配置容量。使用该服务,您可以完全控制您的计算资源,并可以在成熟的 Amazon 计算环境中运行这些资源。Amazon EC2 将获取并启动新服务器实例所需的时间缩短至几分钟,这样一来,在您的计算需求发生变化时,您可以快速地扩展或缩减计算容量。 Amazon EC2 按您实际使用的容量收费,从而使计算服务变得更划算。Amazon EC2 还为开发人员提供了创建故障恢复应用程序以及排除常见故障情况的工具。

华为网课云计算笔记

一、云计算的产生背景1.云计算的产生背景 云计算的驱动力: 1.技术驱动 2.需求驱动 3.商业模式驱动 海量的数据和终端 IT的复杂性、商业延迟也是促进云计算产生的一个因素2.云计算的概念 —商业视角 云计算=信息电厂 –技术视角 云计算=计算/存储的网络 云计算分为狭义和广义两个 狭义的是指:IT技术设施的交付和使用模式,通过按需易扩展的方式获得所需的资源,包括基础架

HY—Chan 1599

云计算课程报告

这是云计算课程设计报告,其中包括AWS四个实验和Hadoop伪分布式安装过程

云计算(课程报告).doc

程 序 设 计 方 法 学 姓名: 班级: 学号: 有"云"蔚然升起 1. 摘要 随着多核处理器、虚拟化、分布式存储、宽带互联网和自动化管理等技术的发展,产 生了一种新型的计算模式——云计算,它能够按需部署计算资源,而用户只需要为所使用 的资源付费。 "云"是列互联网或大型服务器集群的一种比喻,由分布的互联网基础设施,如网络设备 、服务器、存储设备、安全设备等构成,几乎所有的数据和应用软件。都可存储在"云" 里。而"云终端",例如PC、手机、车载电子设备等,只需要拥有一个功能完备的浏览器 ,并安装一个简单的操作系统,通过网络接入"云",就可以轻松使用云中的计算资源。 关键词:CPU 超级计算机 服务器 虚拟机 SaaS 按需部署 企业之争 2. 引言 2007年,云计算作为一种概念被业界关注。仅仅两三年后,云计算就引起了计算机、 互联网和通信行业内的高度关注,正在被越来越多的人所认识和接受,已经成为IT行业 最为炙手可热的中心主题。可以预见,在云计算的大趋势下整个信息服务产业将发生全 面重组洗牌,软件产业结构将面临大调整,软件生产组织方式向敏捷、定制化、服务化 方向变革,网络端设备更加

云计算:KVM和Docker的管理

云计算应该是现如今最火的领域,什么东西沾点云计算都感觉相当的Sophisticated,但真正学了以后发现没那么邪乎,虽然这项技术,或者说这个概念相当牛逼,但是只要这门课有课设,就说明这东西是能被当代大学生做出来(虽然做课设相当头疼) 那么,一个人,一个混子的故事就此开启。两台电脑,无数个日夜,终于将这个作业完成。 下面,全体观众,请欣赏 云计算Ultra Plus Pro Max(都没有)系列 SystemManager类 该模块主要用于全局管理,包括提供KVM和Docker的IP地址等信息 .

qq_51457257的博客 1513

《云计算技术》课程标准.docx

《云计算技术》课程标准 课程名称、代码:云计算技术、 总学时数:36(理论课学时数:8 实践课学时数:28) 学分数:2 适用专业:计算机网络技术 一、课程的性质 1、选修课; 2、专业课。 二、课程定位 该课程是计算机网络技术专业的专业选修课。通过本课程的学习,使学生了解云计算的基础知识和概念,了解虚拟化技术及管理;掌握NFS服务器的配置,掌握yum的配置,掌握Cloudstack安装和配置,掌握基于Cloudstack的云计算平台的管理。学生应先修《网络操作系统应用与配置》一课,掌握Linux的基础知识和操作后,方可修本课程。 三、课程设计思路 本课程的设计思路是以计算机专业学生就业为导向,着重培养学生的动手能力。通过调查研究社会对云计算的配置与管理方面的要求,制定相关的理论教学内容和实践内容。课程以Cloudstack开源云平台的安装、配置与管理为主线,从而让学生掌握云计算的相关知识、相关服务器的配置,加深Linux的使用技能,直至完整掌握Cloudstack。在学时分配上,本课程偏重实践,理论8课时,实践28课时,,着力提高学生的动手能力。 四、课程基本目标 1、知识目标:

关于Cisco“一课一得”计划

关于Cisco的“一课一得”

THF20230101114的博客 1032

WiFi信道状态信息 基于Intel 5300的CSI Tool 安装及使用(一)

经过半个月的坎坷安装过程,连Windows系统都没装过的本人终于颤颤巍巍把CSI TOOL装好了,下面记录一下适于我所使用设备的安装过程。设备:一台THINKPAD X201,一台师兄借的华硕主板的台式机首先,如果你和我一样对linux其实一窍不通的话,建议先反复看教程里的安装代码,照猫画虎很难一步实现的,中途一定会有这或那的问题需要解决,所以该了解的基础linux指令还是要了解,起码安装过程中的那些指令可以去查一查。.........

Silver_777的博客 2万+

RagFlow 文档解析

RAGFlow 的设计哲学是“高质量输入,高质量输出”,它通过提供可解释性和可控性的生成结果,让用户能够信任并依赖于系统提供的答案。

weixin_43008312的博客 4001

云计算不需要网红

前言和目录这篇文章真不是吐槽文章,聊的都是企业服务行业的硬知识,但和云产品云技术云行业关系不大,所以用了笔名没用本名。本文目录如下:我不是也不做网红IT网红要放弃什么?没有面向个人开发者的变现渠道没有面向企业客户的推销能力网红自己创业行不行网红就图自己爽行不行?附录--我放弃过绝佳的炒作机会1. 我不是也不做网红2017年的时候,我开通了这个公众号。当时30岁了,开始有年龄焦虑,而且我很难忍受一种...

weixin_48558260的博客 1347

DAC8568控制器实战:如何用STM32实现多通道同步输出(附完整代码)

本文详细介绍了如何使用STM32微控制器驱动TI的DAC8568多通道DAC控制器,实现高精度的多通道同步模拟信号输出。内容涵盖硬件设计要点、SPI时序精准配置、驱动层命令构建,并重点解析了通过LDAC引脚实现同步更新的核心策略,提供了完整的代码框架和实战案例,帮助工程师快速解决多通道同步输出的工程难题。

weixin_29179311的博客 175

云计算概述(一)(发展过程、定义、发展阶段、云计算榜单)

“云计算”是近年来信息技术领域被关注比较多的话题之一。但对普通人来说,会有这样一个疑问:“云计算到底是什么东西?能给我带来什么好处?”从技术层面讲,“云计算”是一个技术性很强的概念,要想给普通用户解释清楚并非易事。但,在不知不觉中,云计算已经出现在我们日常生活当中,绝大多数人已经在使用它并从中获益。我们每个人的生活都将被云计算逐渐改变,把“云计算“说清楚是很有必要的,因为可以看到,就像互联网一样,云计算已然渗透到人们生活的方方面面,云计算对人们生活的影响将更持久、更彻底。

逆境清醒的博客 6439

Python读取Matlab v7.3数据

文章目录Matlab保存数据Python读取 v7.3 Mat Matlab保存数据 在matlab设置中,常规->MAT文件,选择MATLAB版本7.3或更高版本保存数据。 注意保存数据的文件名为 corre.mat,保存的数据数组为data; 后面python的读取中会用到这两个参数 Python读取 v7.3 Mat 先安装hdf5storage库,再使用以下代码,就可以读取到mat中的数据,注意 import hdf5storage import numpy as np dataDi

weixin_43121914的博客 1083

模型参考自适应控制(MRAC):让PID参数动态优化

本文深入解析模型参考自适应控制(MRAC)技术,它通过实时调整PID参数,使控制系统能自动适应系统特性变化和外部干扰。文章详细介绍了MRAC的工作原理、数学基础,并提供了用C语言实现的实战代码示例,帮助工程师解决传统PID控制在非线性、时变系统中参数整定繁琐的难题。

tequila的博客 903

[云计算小课] 【第八课】云小课教你轻松切换操作系统

如果我们在创建云服务器的时候选错了操作系统,或在云服务器后期使用时有更换其他操作系统的诉求,首先想到的就是切换操作系统功能。 随之我们脑海中就会有一连串的问号:怎样切换ECS的操作系统?切换操作系统复杂吗?切换操作系统后会不会影响我们已有的数据呢? 小课本次就来帮助大家消除这些问号,以切换CentOS 7.3 64bit为Ububtu 16.04操作...

阅识风云的博客 368

辛普森悖论:识别数据聚合偏误与混杂变量的实战指南

辛普森悖论是一种典型的聚合偏误现象,源于未控制的混杂变量导致分组分配不均,使整体统计结果与各子群真实效应方向相反。其本质不是数据错误,而是因果推断框架在忽略结构异质性时的失效。该悖论在医疗临床试验、AB测试、商业归因等高频场景中隐蔽性强、触发门槛低,常造成决策反转。掌握分层分析方法、Cochran-Mantel-Haenszel检验及双Y轴可视化技术,可有效识别并破解误导性汇总结论。本文聚焦辛普森悖论与数据误导两大核心问题,提供从诊断、验证到汇报的全流程工程化应对方案。

weixin_28520495的博客 510
下一篇: 云计算课设(二)
assassinAKL
博客等级 码龄7年 0粉丝 2原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值